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

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

./exp/instancestate/awsinstancestate_controller_test.go
./exp/instancestate/awsinstancestate_controller.go
./pkg/cloud/services/instancestate


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

Solution patch:
diff --git a/controllers/awscluster_controller.go b/controllers/awscluster_controller.go
index 75f4ea9b2..1d0d332f1 100644
--- a/controllers/awscluster_controller.go
+++ b/controllers/awscluster_controller.go
@@ -228,7 +228,7 @@ func (r *AWSClusterReconciler) reconcileDelete(ctx context.Context, clusterScope
 
 	if feature.Gates.Enabled(feature.EventBridgeInstanceState) {
 		instancestateSvc := instancestate.NewService(clusterScope)
-		if err := instancestateSvc.DeleteEC2Events(); err != nil {
+		if err := instancestateSvc.DeleteEC2Events(ctx); err != nil {
 			// Not deleting the events isn't critical to cluster deletion
 			clusterScope.Error(err, "non-fatal: failed to delete EventBridge notifications")
 		}
@@ -348,7 +348,7 @@ func (r *AWSClusterReconciler) reconcileNormal(ctx context.Context, clusterScope
 
 	if feature.Gates.Enabled(feature.EventBridgeInstanceState) {
 		instancestateSvc := instancestate.NewService(clusterScope)
-		if err := instancestateSvc.ReconcileEC2Events(); err != nil {
+		if err := instancestateSvc.ReconcileEC2Events(ctx); err != nil {
 			// non fatal error, so we continue
 			clusterScope.Error(err, "non-fatal: failed to set up EventBridge")
 		}
diff --git a/controllers/awsmachine_controller.go b/controllers/awsmachine_controller.go
index a5543f9a0..317cc204d 100644
--- a/controllers/awsmachine_controller.go
+++ b/controllers/awsmachine_controller.go
@@ -346,7 +346,7 @@ func (r *AWSMachineReconciler) reconcileDelete(ctx context.Context, machineScope
 
 	if feature.Gates.Enabled(feature.EventBridgeInstanceState) {
 		instancestateSvc := instancestate.NewService(ec2Scope)
-		instancestateSvc.RemoveInstanceFromEventPattern(instance.ID)
+		instancestateSvc.RemoveInstanceFromEventPattern(ctx, instance.ID)
 	}
 
 	// Check the instance state. If it's already shutting down or terminated,
@@ -558,7 +558,7 @@ func (r *AWSMachineReconciler) reconcileNormal(ctx context.Context, machineScope
 
 	if feature.Gates.Enabled(feature.EventBridgeInstanceState) {
 		instancestateSvc := instancestate.NewService(ec2Scope)
-		if err := instancestateSvc.AddInstanceToEventPattern(instance.ID); err != nil {
+		if err := instancestateSvc.AddInstanceToEventPattern(ctx, instance.ID); err != nil {
 			return ctrl.Result{}, errors.Wrap(err, "failed to add instance to Event Bridge instance state rule")
 		}
 	}
diff --git a/controlplane/eks/controllers/awsmanagedcontrolplane_controller.go b/controlplane/eks/controllers/awsmanagedcontrolplane_controller.go
index 3e13739ae..a2dda6c2b 100644
--- a/controlplane/eks/controllers/awsmanagedcontrolplane_controller.go
+++ b/controlplane/eks/controllers/awsmanagedcontrolplane_controller.go
@@ -364,7 +364,7 @@ func (r *AWSManagedControlPlaneReconciler) reconcileNormal(ctx context.Context,
 
 	if feature.Gates.Enabled(feature.EventBridgeInstanceState) {
 		instancestateSvc := instancestate.NewService(managedScope)
-		if err := instancestateSvc.ReconcileEC2Events(); err != nil {
+		if err := instancestateSvc.ReconcileEC2Events(ctx); err != nil {
 			// non fatal error, so we continue
 			managedScope.Error(err, "non-fatal: failed to set up EventBridge")
 		}
diff --git a/exp/instancestate/awsinstancestate_controller.go b/exp/instancestate/awsinstancestate_controller.go
index 489f65724..97ccb91f6 100644
--- a/exp/instancestate/awsinstancestate_controller.go
+++ b/exp/instancestate/awsinstancestate_controller.go
@@ -24,10 +24,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/sqs"
-	"github.com/aws/aws-sdk-go/service/sqs/sqsiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	"github.com/go-logr/logr"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/klog/v2"
@@ -38,6 +37,7 @@ import (
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/controllers"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/instancestate"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/logger"
@@ -52,7 +52,7 @@ const Ec2InstanceStateLabelKey = "ec2-instance-state"
 type AwsInstanceStateReconciler struct {
 	client.Client
 	Log               logr.Logger
-	sqsServiceFactory func() sqsiface.SQSAPI
+	sqsServiceFactory func() instancestate.SQSAPI
 	queueURLs         sync.Map
 	Endpoints         []scope.ServiceEndpoint
 	WatchFilterValue  string
@@ -61,7 +61,7 @@ type AwsInstanceStateReconciler struct {
 // +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=awsclusters,verbs=get;list;watch
 // +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=awsmachines,verbs=get;list;watch
 
-func (r *AwsInstanceStateReconciler) getSQSService(region string) (sqsiface.SQSAPI, error) {
+func (r *AwsInstanceStateReconciler) getSQSService(region string) (instancestate.SQSAPI, error) {
 	if r.sqsServiceFactory != nil {
 		return r.sqsServiceFactory(), nil
 	}
@@ -99,7 +99,7 @@ func (r *AwsInstanceStateReconciler) Reconcile(ctx context.Context, req ctrl.Req
 
 	// retrieve queue URL if it isn't already tracked
 	if _, ok := r.queueURLs.Load(awsCluster.Name); !ok {
-		URL, err := r.getQueueURL(awsCluster)
+		URL, err := r.getQueueURL(ctx, awsCluster)
 		if err != nil {
 			if queueNotFoundError(err) {
 				return reconcile.Result{}, nil
@@ -129,7 +129,7 @@ func (r *AwsInstanceStateReconciler) watchQueuesForInstanceEvents() {
 	awsClusterList := &infrav1.AWSClusterList{}
 	if err := r.Client.List(ctx, awsClusterList); err == nil {
 		for i, cluster := range awsClusterList.Items {
-			if URL, err := r.getQueueURL(&awsClusterList.Items[i]); err == nil {
+			if URL, err := r.getQueueURL(ctx, &awsClusterList.Items[i]); err == nil {
 				r.queueURLs.Store(cluster.Name, queueParams{region: cluster.Spec.Region, URL: URL})
 			}
 		}
@@ -144,7 +144,7 @@ func (r *AwsInstanceStateReconciler) watchQueuesForInstanceEvents() {
 					r.Log.Error(err, "unable to create SQS client")
 					return
 				}
-				resp, err := sqsSvs.ReceiveMessage(&sqs.ReceiveMessageInput{QueueUrl: aws.String(qp.URL)})
+				resp, err := sqsSvs.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{QueueUrl: aws.String(qp.URL)})
 				if err != nil {
 					r.Log.Error(err, "failed to receive messages")
 					return
@@ -160,7 +160,7 @@ func (r *AwsInstanceStateReconciler) watchQueuesForInstanceEvents() {
 					// TODO: handle errors during process message. We currently deletes the message regardless.
 					r.processMessage(ctx, m)
 
-					_, err = sqsSvs.DeleteMessage(&sqs.DeleteMessageInput{
+					_, err = sqsSvs.DeleteMessage(ctx, &sqs.DeleteMessageInput{
 						QueueUrl:      aws.String(qp.URL),
 						ReceiptHandle: msg.ReceiptHandle,
 					})
@@ -216,13 +216,13 @@ func (r *AwsInstanceStateReconciler) processMessage(ctx context.Context, msg mes
 }
 
 // getQueueURL retrieves the SQS queue URL for a given cluster.
-func (r *AwsInstanceStateReconciler) getQueueURL(cluster *infrav1.AWSCluster) (string, error) {
+func (r *AwsInstanceStateReconciler) getQueueURL(ctx context.Context, cluster *infrav1.AWSCluster) (string, error) {
 	sqsSvs, err := r.getSQSService(cluster.Spec.Region)
 	if err != nil {
 		return "", err
 	}
 	queueName := instancestate.GenerateQueueName(cluster.Name)
-	resp, err := sqsSvs.GetQueueUrl(&sqs.GetQueueUrlInput{QueueName: aws.String(queueName)})
+	resp, err := sqsSvs.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{QueueName: aws.String(queueName)})
 
 	if err != nil {
 		return "", err
@@ -232,12 +232,11 @@ func (r *AwsInstanceStateReconciler) getQueueURL(cluster *infrav1.AWSCluster) (s
 }
 
 func queueNotFoundError(err error) bool {
-	if aerr, ok := err.(awserr.Error); ok {
-		if aerr.Code() == sqs.ErrCodeQueueDoesNotExist {
-			return true
-		}
+	smithyErr := awserrors.ParseSmithyError(err)
+	if smithyErr == nil {
+		return false
 	}
-	return false
+	return smithyErr.ErrorCode() == (&sqstypes.QueueDoesNotExist{}).ErrorCode()
 }
 
 type queueParams struct {
diff --git a/go.mod b/go.mod
index 8894dc395..493d8e7f6 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/aws/amazon-vpc-cni-k8s v1.15.5
 	github.com/aws/aws-lambda-go v1.41.0
 	github.com/aws/aws-sdk-go v1.55.5
-	github.com/aws/aws-sdk-go-v2 v1.36.3
+	github.com/aws/aws-sdk-go-v2 v1.36.5
 	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
@@ -16,7 +16,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/iam v1.32.0
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1
 	github.com/aws/aws-sdk-go-v2/service/sts v1.28.6
-	github.com/aws/smithy-go v1.22.2
+	github.com/aws/smithy-go v1.22.4
 	github.com/awslabs/goformation/v4 v4.19.5
 	github.com/blang/semver v3.5.1+incompatible
 	github.com/coreos/ignition v0.35.0
@@ -80,12 +80,13 @@ require (
 	github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535 // indirect
 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 // indirect
 	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.36 // indirect
 	github.com/aws/aws-sdk-go-v2/service/cloudformation v1.50.0 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/eventbridge v1.39.3
 	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.7 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7 // indirect
@@ -93,6 +94,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/organizations v1.27.3 // indirect
 	github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.28.6 // indirect
 	github.com/aws/aws-sdk-go-v2/service/servicequotas v1.21.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sqs v1.38.8
 	github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 // indirect
 	github.com/aymerick/douceur v0.2.0 // indirect
diff --git a/go.sum b/go.sum
index 4d51df71d..9a00918d6 100644
--- a/go.sum
+++ b/go.sum
@@ -48,8 +48,8 @@ github.com/aws/aws-lambda-go v1.41.0 h1:l/5fyVb6Ud9uYd411xdHZzSf2n86TakxzpvIoz7l
 github.com/aws/aws-lambda-go v1.41.0/go.mod h1:jwFe2KmMsHmffA1X2R09hH6lFzJQxzI8qK17ewzbQMM=
 github.com/aws/aws-sdk-go v1.55.5 h1:KKUZBfBoyqy5d3swXyiC7Q76ic40rYcbqH7qjh59kzU=
 github.com/aws/aws-sdk-go v1.55.5/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
-github.com/aws/aws-sdk-go-v2 v1.36.3 h1:mJoei2CxPutQVxaATCzDUjcZEjVRdpsiiXi2o38yqWM=
-github.com/aws/aws-sdk-go-v2 v1.36.3/go.mod h1:LLXuLpgzEbD766Z5ECcRmi8AzSwfZItDtmABVkRLGzg=
+github.com/aws/aws-sdk-go-v2 v1.36.5 h1:0OF9RiEMEdDdZEMqF9MRjevyxAQcf6gY+E7vwBILFj0=
+github.com/aws/aws-sdk-go-v2 v1.36.5/go.mod h1:EYrzvCCN9CMUTa5+6lf6MM4tq3Zjp8UhSGR/cBsjai0=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 h1:x6xsQXGSmW6frevwDA+vi/wqhp1ct18mVXYN08/93to=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2/go.mod h1:lPprDr1e6cJdyYeGXnRaJoP4Md+cDBvi2eOj00BlGmg=
 github.com/aws/aws-sdk-go-v2/config v1.27.11 h1:f47rANd2LQEYHda2ddSCKYId18/8BhSRM4BULGmfgNA=
@@ -58,14 +58,14 @@ github.com/aws/aws-sdk-go-v2/credentials v1.17.11 h1:YuIB1dJNf1Re822rriUOTxopaHH
 github.com/aws/aws-sdk-go-v2/credentials v1.17.11/go.mod h1:AQtFPsDH9bI2O+71anW6EKL+NcD7LG3dpKGMV4SShgo=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 h1:FVJ0r5XTHSmIHJV6KuDmdYhEpvlHpiSd38RQWhut5J4=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1/go.mod h1:zusuAeqezXzAB24LGuzuekqMAEgWkVYukBec3kr3jUg=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 h1:ZK5jHhnrioRkUNOc+hOgQKlUL5JeC3S6JgLxtQ+Rm0Q=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34/go.mod h1:p4VfIceZokChbA9FzMbRGz5OV+lekcVtHlPKEO0gSZY=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 h1:SZwFm17ZUNNg5Np0ioo/gq8Mn6u9w19Mri8DnJ15Jf0=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34/go.mod h1:dFZsC0BLo346mvKQLWmoJxT+Sjp+qcVR1tRVHQGOH9Q=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36 h1:SsytQyTMHMDPspp+spo7XwXTP44aJZZAC7fBV2C5+5s=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36/go.mod h1:Q1lnJArKRXkenyog6+Y+zr7WDpk4e6XlR6gs20bbeNo=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36 h1:i2vNHQiXUvKhs3quBR6aqlgJaiaexz/aNvdCktW/kAM=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36/go.mod h1:UdyGa7Q91id/sdyHPwth+043HhmP6yP9MBHgbZM0xo8=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5 h1:81KE7vaZzrl7yHBYHVEzYB8sypz11NMOZ40YlWvPxsU=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5/go.mod h1:LIt2rg7Mcgn09Ygbdh/RdIm0rQ+3BNkbP1gyVMFtRK0=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.36 h1:GMYy2EOWfzdP3wfVAGXBNKY5vK4K8vMET4sYOYltmqs=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.36/go.mod h1:gDhdAV6wL3PmPqBhiPbnlS447GoWs8HTTOYef9/9Inw=
 github.com/aws/aws-sdk-go-v2/service/autoscaling v1.52.4 h1:vzLD0FyNU4uxf2QE5UDG0jSEitiJXbVEUwf2Sk3usF4=
 github.com/aws/aws-sdk-go-v2/service/autoscaling v1.52.4/go.mod h1:CDqMoc3KRdZJ8qziW96J35lKH01Wq3B2aihtHj2JbRs=
 github.com/aws/aws-sdk-go-v2/service/cloudformation v1.50.0 h1:Ap5tOJfeAH1hO2UQc3X3uMlwP7uryFeZXMvZCXIlLSE=
@@ -74,6 +74,8 @@ github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0 h1:DmmVmiLPlcntOcjWMRwDPMNx/wi
 github.com/aws/aws-sdk-go-v2/service/ec2 v1.159.0/go.mod h1:xejKuuRDjz6z5OqyeLsz01MlOqqW7CqpAB4PabNvpu8=
 github.com/aws/aws-sdk-go-v2/service/eks v1.64.0 h1:EYeOThTRysemFtC6J6h6b7dNg3jN03QuO5cg92ojIQE=
 github.com/aws/aws-sdk-go-v2/service/eks v1.64.0/go.mod h1:v1xXy6ea0PHtWkjFUvAUh6B/5wv7UF909Nru0dOIJDk=
+github.com/aws/aws-sdk-go-v2/service/eventbridge v1.39.3 h1:T6L7fsONflMeXuvsT8qZ247hA8ShBB0jF9yUEhW4JqI=
+github.com/aws/aws-sdk-go-v2/service/eventbridge v1.39.3/go.mod h1:sIrUII6Z+hAVAgcpmsc2e9HvEr++m/v8aBPT7s4ZYUk=
 github.com/aws/aws-sdk-go-v2/service/iam v1.32.0 h1:ZNlfPdw849gBo/lvLFbEEvpTJMij0LXqiNWZ+lIamlU=
 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=
@@ -92,14 +94,16 @@ github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.28.6 h1:TIOEjw0i2yyhmhRry
 github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.28.6/go.mod h1:3Ba++UwWd154xtP4FRX5pUK3Gt4up5sDHCve6kVfE+g=
 github.com/aws/aws-sdk-go-v2/service/servicequotas v1.21.4 h1:SSDkZRAO8Ok5SoQ4BJ0onDeb0ga8JBOCkUmNEpRChcw=
 github.com/aws/aws-sdk-go-v2/service/servicequotas v1.21.4/go.mod h1:plXue/Zg49kU3uU6WwfCWgRR5SRINNiJf03Y/UhYOhU=
+github.com/aws/aws-sdk-go-v2/service/sqs v1.38.8 h1:80dpSqWMwx2dAm30Ib7J6ucz1ZHfiv5OCRwN/EnCOXQ=
+github.com/aws/aws-sdk-go-v2/service/sqs v1.38.8/go.mod h1:IzNt/udsXlETCdvBOL0nmyMe2t9cGmXmZgsdoZGYYhI=
 github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 h1:vN8hEbpRnL7+Hopy9dzmRle1xmDc7o8tmY0klsr175w=
 github.com/aws/aws-sdk-go-v2/service/sso v1.20.5/go.mod h1:qGzynb/msuZIE8I75DVRCUXw3o3ZyBmUvMwQ2t/BrGM=
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 h1:Jux+gDDyi1Lruk+KHF91tK2KCuY61kzoCpvtvJJBtOE=
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4/go.mod h1:mUYPBhaF2lGiukDEjJX2BLRRKTmoUSitGDUgM4tRxak=
 github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 h1:cwIxeBttqPN3qkaAjcEcsh8NYr8n2HZPkcKgPAi1phU=
 github.com/aws/aws-sdk-go-v2/service/sts v1.28.6/go.mod h1:FZf1/nKNEkHdGGJP/cI2MoIMquumuRK6ol3QQJNDxmw=
-github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
-github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
+github.com/aws/smithy-go v1.22.4 h1:uqXzVZNuNexwc/xrh6Tb56u89WDlJY6HS+KC0S4QSjw=
+github.com/aws/smithy-go v1.22.4/go.mod h1:t1ufH5HMublsJYulve2RKmHDC15xu1f26kHCp/HgceI=
 github.com/awslabs/goformation/v4 v4.19.5 h1:Y+Tzh01tWg8gf//AgGKUamaja7Wx9NPiJf1FpZu4/iU=
 github.com/awslabs/goformation/v4 v4.19.5/go.mod h1:JoNpnVCBOUtEz9bFxc9sjy8uBUCLF5c4D1L7RhRTVM8=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
diff --git a/pkg/cloud/metricsv2/metrics.go b/pkg/cloud/metricsv2/metrics.go
index 8649c6584..c8620e3da 100644
--- a/pkg/cloud/metricsv2/metrics.go
+++ b/pkg/cloud/metricsv2/metrics.go
@@ -112,6 +112,13 @@ func WithCAPAUserAgentMiddleware() func(*middleware.Stack) error {
 	return awsmiddleware.AddUserAgentKeyValue("aws.cluster.x-k8s.io", version.Get().String())
 }
 
+// WithRequestMetricContextMiddleware returns Request Metric middleware stack for AWS GO SDK V2 sessions.
+func WithRequestMetricContextMiddleware() func(*middleware.Stack) error {
+	return func(stack *middleware.Stack) error {
+		return stack.Finalize.Add(getRequestMetricContextMiddleware(), middleware.Before)
+	}
+}
+
 func getMetricCollectionMiddleware(controller string, target runtime.Object) middleware.InitializeMiddleware {
 	return middleware.InitializeMiddlewareFunc("capa/MetricCollectionMiddleware", func(ctx context.Context, input middleware.InitializeInput, handler middleware.InitializeHandler) (middleware.InitializeOutput, middleware.Metadata, error) {
 		ctx = initRequestContext(ctx, controller, target)
diff --git a/pkg/cloud/scope/clients.go b/pkg/cloud/scope/clients.go
index 48962fdc9..b84b490ce 100644
--- a/pkg/cloud/scope/clients.go
+++ b/pkg/cloud/scope/clients.go
@@ -19,8 +19,10 @@ package scope
 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-v2/service/eventbridge"
 	"github.com/aws/aws-sdk-go-v2/service/iam"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
@@ -30,14 +32,10 @@ import (
 	"github.com/aws/aws-sdk-go/service/elb/elbiface"
 	"github.com/aws/aws-sdk-go/service/elbv2"
 	"github.com/aws/aws-sdk-go/service/elbv2/elbv2iface"
-	"github.com/aws/aws-sdk-go/service/eventbridge"
-	"github.com/aws/aws-sdk-go/service/eventbridge/eventbridgeiface"
 	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
 	"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface"
 	"github.com/aws/aws-sdk-go/service/secretsmanager"
 	"github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface"
-	"github.com/aws/aws-sdk-go/service/sqs"
-	"github.com/aws/aws-sdk-go/service/sqs/sqsiface"
 	"github.com/aws/aws-sdk-go/service/ssm"
 	"github.com/aws/aws-sdk-go/service/ssm/ssmiface"
 	"github.com/aws/aws-sdk-go/service/sts"
@@ -113,32 +111,45 @@ func NewELBv2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger lo
 }
 
 // NewEventBridgeClient creates a new EventBridge API client for a given session.
-func NewEventBridgeClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runtime.Object) eventbridgeiface.EventBridgeAPI {
-	eventBridgeClient := eventbridge.New(session.Session())
-	eventBridgeClient.Handlers.Build.PushFrontNamed(getUserAgentHandler())
-	eventBridgeClient.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
-	eventBridgeClient.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target))
+func NewEventBridgeClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runtime.Object) *eventbridge.Client {
+	cfg := session.SessionV2()
 
-	return eventBridgeClient
+	opts := []func(*eventbridge.Options){
+		eventbridge.WithAPIOptions(
+			awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target),
+			awsmetricsv2.WithCAPAUserAgentMiddleware(),
+		),
+	}
+
+	return eventbridge.NewFromConfig(cfg, opts...)
 }
 
 // NewSQSClient creates a new SQS API client for a given session.
-func NewSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runtime.Object) sqsiface.SQSAPI {
-	SQSClient := sqs.New(session.Session())
-	SQSClient.Handlers.Build.PushFrontNamed(getUserAgentHandler())
-	SQSClient.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
-	SQSClient.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target))
+func NewSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runtime.Object) *sqs.Client {
+	cfg := session.SessionV2()
 
-	return SQSClient
+	opts := []func(*sqs.Options){
+		sqs.WithAPIOptions(
+			awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target),
+			awsmetricsv2.WithCAPAUserAgentMiddleware(),
+		),
+	}
+
+	return sqs.NewFromConfig(cfg, opts...)
 }
 
 // NewGlobalSQSClient for creating a new SQS API client that isn't tied to a cluster.
-func NewGlobalSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session) sqsiface.SQSAPI {
-	SQSClient := sqs.New(session.Session())
-	SQSClient.Handlers.Build.PushFrontNamed(getUserAgentHandler())
-	SQSClient.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
+func NewGlobalSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session) *sqs.Client {
+	cfg := session.SessionV2()
+
+	opts := []func(*sqs.Options){
+		sqs.WithAPIOptions(
+			awsmetricsv2.WithRequestMetricContextMiddleware(),
+			awsmetricsv2.WithCAPAUserAgentMiddleware(),
+		),
+	}
 
-	return SQSClient
+	return sqs.NewFromConfig(cfg, opts...)
 }
 
 // NewResourgeTaggingClient creates a new Resource Tagging API client for a given session.
diff --git a/pkg/cloud/services/instancestate/ec2events.go b/pkg/cloud/services/instancestate/ec2events.go
index e30ee546d..30939b614 100644
--- a/pkg/cloud/services/instancestate/ec2events.go
+++ b/pkg/cloud/services/instancestate/ec2events.go
@@ -16,20 +16,22 @@ limitations under the License.
 
 package instancestate
 
+import "context"
+
 // ReconcileEC2Events will reconcile a Service's EC2 events.
-func (s Service) ReconcileEC2Events() error {
-	if err := s.reconcileSQSQueue(); err != nil {
+func (s Service) ReconcileEC2Events(ctx context.Context) error {
+	if err := s.reconcileSQSQueue(ctx); err != nil {
 		return err
 	}
 
-	return s.reconcileRules()
+	return s.reconcileRules(ctx)
 }
 
 // DeleteEC2Events will delete a Service's EC2 events.
-func (s Service) DeleteEC2Events() error {
-	if err := s.deleteRules(); err != nil {
+func (s Service) DeleteEC2Events(ctx context.Context) error {
+	if err := s.deleteRules(ctx); err != nil {
 		return err
 	}
 
-	return s.deleteSQSQueue()
+	return s.deleteSQSQueue(ctx)
 }
diff --git a/pkg/cloud/services/instancestate/mock_eventbridgeiface/doc.go b/pkg/cloud/services/instancestate/mock_eventbridgeiface/doc.go
index 9d3af84e3..3861e9944 100644
--- a/pkg/cloud/services/instancestate/mock_eventbridgeiface/doc.go
+++ b/pkg/cloud/services/instancestate/mock_eventbridgeiface/doc.go
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 // Run go generate to regenerate this mock.
-//go:generate ../../../../../hack/tools/bin/mockgen -destination eventbridgeiface_mock.go -package mock_eventbridgeiface github.com/aws/aws-sdk-go/service/eventbridge/eventbridgeiface EventBridgeAPI
+//go:generate ../../../../../hack/tools/bin/mockgen -destination eventbridgeiface_mock.go -package mock_eventbridgeiface sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/instancestate EventBridgeAPI
 //go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt eventbridgeiface_mock.go > _eventbridgeiface_mock.go && mv _eventbridgeiface_mock.go eventbridgeiface_mock.go"
 
 // Package mock_eventbridgeiface provides a mock implementation for the EventBridgeAPI interface.
diff --git a/pkg/cloud/services/instancestate/mock_eventbridgeiface/eventbridgeiface_mock.go b/pkg/cloud/services/instancestate/mock_eventbridgeiface/eventbridgeiface_mock.go
index c3c12de97..275f0a2f8 100644
--- a/pkg/cloud/services/instancestate/mock_eventbridgeiface/eventbridgeiface_mock.go
+++ b/pkg/cloud/services/instancestate/mock_eventbridgeiface/eventbridgeiface_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/eventbridge/eventbridgeiface (interfaces: EventBridgeAPI)
+// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/instancestate (interfaces: EventBridgeAPI)
 
 // Package mock_eventbridgeiface is a generated GoMock package.
 package mock_eventbridgeiface
@@ -24,8 +24,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	request "github.com/aws/aws-sdk-go/aws/request"
-	eventbridge "github.com/aws/aws-sdk-go/service/eventbridge"
+	eventbridge "github.com/aws/aws-sdk-go-v2/service/eventbridge"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -52,2852 +51,122 @@ func (m *MockEventBridgeAPI) EXPECT() *MockEventBridgeAPIMockRecorder {
 	return m.recorder
 }
 
-// ActivateEventSource mocks base method.
-func (m *MockEventBridgeAPI) ActivateEventSource(arg0 *eventbridge.ActivateEventSourceInput) (*eventbridge.ActivateEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ActivateEventSource", arg0)
-	ret0, _ := ret[0].(*eventbridge.ActivateEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ActivateEventSource indicates an expected call of ActivateEventSource.
-func (mr *MockEventBridgeAPIMockRecorder) ActivateEventSource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateEventSource", reflect.TypeOf((*MockEventBridgeAPI)(nil).ActivateEventSource), arg0)
-}
-
-// ActivateEventSourceRequest mocks base method.
-func (m *MockEventBridgeAPI) ActivateEventSourceRequest(arg0 *eventbridge.ActivateEventSourceInput) (*request.Request, *eventbridge.ActivateEventSourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ActivateEventSourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ActivateEventSourceOutput)
-	return ret0, ret1
-}
-
-// ActivateEventSourceRequest indicates an expected call of ActivateEventSourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ActivateEventSourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateEventSourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ActivateEventSourceRequest), arg0)
-}
-
-// ActivateEventSourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) ActivateEventSourceWithContext(arg0 context.Context, arg1 *eventbridge.ActivateEventSourceInput, arg2 ...request.Option) (*eventbridge.ActivateEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ActivateEventSourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ActivateEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ActivateEventSourceWithContext indicates an expected call of ActivateEventSourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ActivateEventSourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateEventSourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ActivateEventSourceWithContext), varargs...)
-}
-
-// CancelReplay mocks base method.
-func (m *MockEventBridgeAPI) CancelReplay(arg0 *eventbridge.CancelReplayInput) (*eventbridge.CancelReplayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelReplay", arg0)
-	ret0, _ := ret[0].(*eventbridge.CancelReplayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelReplay indicates an expected call of CancelReplay.
-func (mr *MockEventBridgeAPIMockRecorder) CancelReplay(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReplay", reflect.TypeOf((*MockEventBridgeAPI)(nil).CancelReplay), arg0)
-}
-
-// CancelReplayRequest mocks base method.
-func (m *MockEventBridgeAPI) CancelReplayRequest(arg0 *eventbridge.CancelReplayInput) (*request.Request, *eventbridge.CancelReplayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelReplayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.CancelReplayOutput)
-	return ret0, ret1
-}
-
-// CancelReplayRequest indicates an expected call of CancelReplayRequest.
-func (mr *MockEventBridgeAPIMockRecorder) CancelReplayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReplayRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).CancelReplayRequest), arg0)
-}
-
-// CancelReplayWithContext mocks base method.
-func (m *MockEventBridgeAPI) CancelReplayWithContext(arg0 context.Context, arg1 *eventbridge.CancelReplayInput, arg2 ...request.Option) (*eventbridge.CancelReplayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelReplayWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.CancelReplayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelReplayWithContext indicates an expected call of CancelReplayWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) CancelReplayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReplayWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).CancelReplayWithContext), varargs...)
-}
-
-// CreateApiDestination mocks base method.
-func (m *MockEventBridgeAPI) CreateApiDestination(arg0 *eventbridge.CreateApiDestinationInput) (*eventbridge.CreateApiDestinationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateApiDestination", arg0)
-	ret0, _ := ret[0].(*eventbridge.CreateApiDestinationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateApiDestination indicates an expected call of CreateApiDestination.
-func (mr *MockEventBridgeAPIMockRecorder) CreateApiDestination(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApiDestination", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateApiDestination), arg0)
-}
-
-// CreateApiDestinationRequest mocks base method.
-func (m *MockEventBridgeAPI) CreateApiDestinationRequest(arg0 *eventbridge.CreateApiDestinationInput) (*request.Request, *eventbridge.CreateApiDestinationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateApiDestinationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.CreateApiDestinationOutput)
-	return ret0, ret1
-}
-
-// CreateApiDestinationRequest indicates an expected call of CreateApiDestinationRequest.
-func (mr *MockEventBridgeAPIMockRecorder) CreateApiDestinationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApiDestinationRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateApiDestinationRequest), arg0)
-}
-
-// CreateApiDestinationWithContext mocks base method.
-func (m *MockEventBridgeAPI) CreateApiDestinationWithContext(arg0 context.Context, arg1 *eventbridge.CreateApiDestinationInput, arg2 ...request.Option) (*eventbridge.CreateApiDestinationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateApiDestinationWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.CreateApiDestinationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateApiDestinationWithContext indicates an expected call of CreateApiDestinationWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) CreateApiDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApiDestinationWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateApiDestinationWithContext), varargs...)
-}
-
-// CreateArchive mocks base method.
-func (m *MockEventBridgeAPI) CreateArchive(arg0 *eventbridge.CreateArchiveInput) (*eventbridge.CreateArchiveOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateArchive", arg0)
-	ret0, _ := ret[0].(*eventbridge.CreateArchiveOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateArchive indicates an expected call of CreateArchive.
-func (mr *MockEventBridgeAPIMockRecorder) CreateArchive(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateArchive", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateArchive), arg0)
-}
-
-// CreateArchiveRequest mocks base method.
-func (m *MockEventBridgeAPI) CreateArchiveRequest(arg0 *eventbridge.CreateArchiveInput) (*request.Request, *eventbridge.CreateArchiveOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateArchiveRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.CreateArchiveOutput)
-	return ret0, ret1
-}
-
-// CreateArchiveRequest indicates an expected call of CreateArchiveRequest.
-func (mr *MockEventBridgeAPIMockRecorder) CreateArchiveRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateArchiveRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateArchiveRequest), arg0)
-}
-
-// CreateArchiveWithContext mocks base method.
-func (m *MockEventBridgeAPI) CreateArchiveWithContext(arg0 context.Context, arg1 *eventbridge.CreateArchiveInput, arg2 ...request.Option) (*eventbridge.CreateArchiveOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateArchiveWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.CreateArchiveOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateArchiveWithContext indicates an expected call of CreateArchiveWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) CreateArchiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateArchiveWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateArchiveWithContext), varargs...)
-}
-
-// CreateConnection mocks base method.
-func (m *MockEventBridgeAPI) CreateConnection(arg0 *eventbridge.CreateConnectionInput) (*eventbridge.CreateConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateConnection", arg0)
-	ret0, _ := ret[0].(*eventbridge.CreateConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateConnection indicates an expected call of CreateConnection.
-func (mr *MockEventBridgeAPIMockRecorder) CreateConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConnection", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateConnection), arg0)
-}
-
-// CreateConnectionRequest mocks base method.
-func (m *MockEventBridgeAPI) CreateConnectionRequest(arg0 *eventbridge.CreateConnectionInput) (*request.Request, *eventbridge.CreateConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.CreateConnectionOutput)
-	return ret0, ret1
-}
-
-// CreateConnectionRequest indicates an expected call of CreateConnectionRequest.
-func (mr *MockEventBridgeAPIMockRecorder) CreateConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConnectionRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateConnectionRequest), arg0)
-}
-
-// CreateConnectionWithContext mocks base method.
-func (m *MockEventBridgeAPI) CreateConnectionWithContext(arg0 context.Context, arg1 *eventbridge.CreateConnectionInput, arg2 ...request.Option) (*eventbridge.CreateConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.CreateConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateConnectionWithContext indicates an expected call of CreateConnectionWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) CreateConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConnectionWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateConnectionWithContext), varargs...)
-}
-
-// CreateEndpoint mocks base method.
-func (m *MockEventBridgeAPI) CreateEndpoint(arg0 *eventbridge.CreateEndpointInput) (*eventbridge.CreateEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateEndpoint", arg0)
-	ret0, _ := ret[0].(*eventbridge.CreateEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateEndpoint indicates an expected call of CreateEndpoint.
-func (mr *MockEventBridgeAPIMockRecorder) CreateEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEndpoint", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateEndpoint), arg0)
-}
-
-// CreateEndpointRequest mocks base method.
-func (m *MockEventBridgeAPI) CreateEndpointRequest(arg0 *eventbridge.CreateEndpointInput) (*request.Request, *eventbridge.CreateEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.CreateEndpointOutput)
-	return ret0, ret1
-}
-
-// CreateEndpointRequest indicates an expected call of CreateEndpointRequest.
-func (mr *MockEventBridgeAPIMockRecorder) CreateEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEndpointRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateEndpointRequest), arg0)
-}
-
-// CreateEndpointWithContext mocks base method.
-func (m *MockEventBridgeAPI) CreateEndpointWithContext(arg0 context.Context, arg1 *eventbridge.CreateEndpointInput, arg2 ...request.Option) (*eventbridge.CreateEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.CreateEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateEndpointWithContext indicates an expected call of CreateEndpointWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) CreateEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEndpointWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateEndpointWithContext), varargs...)
-}
-
-// CreateEventBus mocks base method.
-func (m *MockEventBridgeAPI) CreateEventBus(arg0 *eventbridge.CreateEventBusInput) (*eventbridge.CreateEventBusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateEventBus", arg0)
-	ret0, _ := ret[0].(*eventbridge.CreateEventBusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateEventBus indicates an expected call of CreateEventBus.
-func (mr *MockEventBridgeAPIMockRecorder) CreateEventBus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventBus", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateEventBus), arg0)
-}
-
-// CreateEventBusRequest mocks base method.
-func (m *MockEventBridgeAPI) CreateEventBusRequest(arg0 *eventbridge.CreateEventBusInput) (*request.Request, *eventbridge.CreateEventBusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateEventBusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.CreateEventBusOutput)
-	return ret0, ret1
-}
-
-// CreateEventBusRequest indicates an expected call of CreateEventBusRequest.
-func (mr *MockEventBridgeAPIMockRecorder) CreateEventBusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventBusRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateEventBusRequest), arg0)
-}
-
-// CreateEventBusWithContext mocks base method.
-func (m *MockEventBridgeAPI) CreateEventBusWithContext(arg0 context.Context, arg1 *eventbridge.CreateEventBusInput, arg2 ...request.Option) (*eventbridge.CreateEventBusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreateEventBusWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.CreateEventBusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateEventBusWithContext indicates an expected call of CreateEventBusWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) CreateEventBusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEventBusWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreateEventBusWithContext), varargs...)
-}
-
-// CreatePartnerEventSource mocks base method.
-func (m *MockEventBridgeAPI) CreatePartnerEventSource(arg0 *eventbridge.CreatePartnerEventSourceInput) (*eventbridge.CreatePartnerEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreatePartnerEventSource", arg0)
-	ret0, _ := ret[0].(*eventbridge.CreatePartnerEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreatePartnerEventSource indicates an expected call of CreatePartnerEventSource.
-func (mr *MockEventBridgeAPIMockRecorder) CreatePartnerEventSource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePartnerEventSource", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreatePartnerEventSource), arg0)
-}
-
-// CreatePartnerEventSourceRequest mocks base method.
-func (m *MockEventBridgeAPI) CreatePartnerEventSourceRequest(arg0 *eventbridge.CreatePartnerEventSourceInput) (*request.Request, *eventbridge.CreatePartnerEventSourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreatePartnerEventSourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.CreatePartnerEventSourceOutput)
-	return ret0, ret1
-}
-
-// CreatePartnerEventSourceRequest indicates an expected call of CreatePartnerEventSourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) CreatePartnerEventSourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePartnerEventSourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreatePartnerEventSourceRequest), arg0)
-}
-
-// CreatePartnerEventSourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) CreatePartnerEventSourceWithContext(arg0 context.Context, arg1 *eventbridge.CreatePartnerEventSourceInput, arg2 ...request.Option) (*eventbridge.CreatePartnerEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CreatePartnerEventSourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.CreatePartnerEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreatePartnerEventSourceWithContext indicates an expected call of CreatePartnerEventSourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) CreatePartnerEventSourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePartnerEventSourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).CreatePartnerEventSourceWithContext), varargs...)
-}
-
-// DeactivateEventSource mocks base method.
-func (m *MockEventBridgeAPI) DeactivateEventSource(arg0 *eventbridge.DeactivateEventSourceInput) (*eventbridge.DeactivateEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeactivateEventSource", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeactivateEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeactivateEventSource indicates an expected call of DeactivateEventSource.
-func (mr *MockEventBridgeAPIMockRecorder) DeactivateEventSource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateEventSource", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeactivateEventSource), arg0)
-}
-
-// DeactivateEventSourceRequest mocks base method.
-func (m *MockEventBridgeAPI) DeactivateEventSourceRequest(arg0 *eventbridge.DeactivateEventSourceInput) (*request.Request, *eventbridge.DeactivateEventSourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeactivateEventSourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeactivateEventSourceOutput)
-	return ret0, ret1
-}
-
-// DeactivateEventSourceRequest indicates an expected call of DeactivateEventSourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeactivateEventSourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateEventSourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeactivateEventSourceRequest), arg0)
-}
-
-// DeactivateEventSourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeactivateEventSourceWithContext(arg0 context.Context, arg1 *eventbridge.DeactivateEventSourceInput, arg2 ...request.Option) (*eventbridge.DeactivateEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeactivateEventSourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeactivateEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeactivateEventSourceWithContext indicates an expected call of DeactivateEventSourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeactivateEventSourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateEventSourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeactivateEventSourceWithContext), varargs...)
-}
-
-// DeauthorizeConnection mocks base method.
-func (m *MockEventBridgeAPI) DeauthorizeConnection(arg0 *eventbridge.DeauthorizeConnectionInput) (*eventbridge.DeauthorizeConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeauthorizeConnection", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeauthorizeConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeauthorizeConnection indicates an expected call of DeauthorizeConnection.
-func (mr *MockEventBridgeAPIMockRecorder) DeauthorizeConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeauthorizeConnection", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeauthorizeConnection), arg0)
-}
-
-// DeauthorizeConnectionRequest mocks base method.
-func (m *MockEventBridgeAPI) DeauthorizeConnectionRequest(arg0 *eventbridge.DeauthorizeConnectionInput) (*request.Request, *eventbridge.DeauthorizeConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeauthorizeConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeauthorizeConnectionOutput)
-	return ret0, ret1
-}
-
-// DeauthorizeConnectionRequest indicates an expected call of DeauthorizeConnectionRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeauthorizeConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeauthorizeConnectionRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeauthorizeConnectionRequest), arg0)
-}
-
-// DeauthorizeConnectionWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeauthorizeConnectionWithContext(arg0 context.Context, arg1 *eventbridge.DeauthorizeConnectionInput, arg2 ...request.Option) (*eventbridge.DeauthorizeConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeauthorizeConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeauthorizeConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeauthorizeConnectionWithContext indicates an expected call of DeauthorizeConnectionWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeauthorizeConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeauthorizeConnectionWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeauthorizeConnectionWithContext), varargs...)
-}
-
-// DeleteApiDestination mocks base method.
-func (m *MockEventBridgeAPI) DeleteApiDestination(arg0 *eventbridge.DeleteApiDestinationInput) (*eventbridge.DeleteApiDestinationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteApiDestination", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeleteApiDestinationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteApiDestination indicates an expected call of DeleteApiDestination.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteApiDestination(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteApiDestination", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteApiDestination), arg0)
-}
-
-// DeleteApiDestinationRequest mocks base method.
-func (m *MockEventBridgeAPI) DeleteApiDestinationRequest(arg0 *eventbridge.DeleteApiDestinationInput) (*request.Request, *eventbridge.DeleteApiDestinationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteApiDestinationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeleteApiDestinationOutput)
-	return ret0, ret1
-}
-
-// DeleteApiDestinationRequest indicates an expected call of DeleteApiDestinationRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteApiDestinationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteApiDestinationRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteApiDestinationRequest), arg0)
-}
-
-// DeleteApiDestinationWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeleteApiDestinationWithContext(arg0 context.Context, arg1 *eventbridge.DeleteApiDestinationInput, arg2 ...request.Option) (*eventbridge.DeleteApiDestinationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteApiDestinationWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeleteApiDestinationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteApiDestinationWithContext indicates an expected call of DeleteApiDestinationWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteApiDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteApiDestinationWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteApiDestinationWithContext), varargs...)
-}
-
-// DeleteArchive mocks base method.
-func (m *MockEventBridgeAPI) DeleteArchive(arg0 *eventbridge.DeleteArchiveInput) (*eventbridge.DeleteArchiveOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteArchive", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeleteArchiveOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteArchive indicates an expected call of DeleteArchive.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteArchive(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteArchive", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteArchive), arg0)
-}
-
-// DeleteArchiveRequest mocks base method.
-func (m *MockEventBridgeAPI) DeleteArchiveRequest(arg0 *eventbridge.DeleteArchiveInput) (*request.Request, *eventbridge.DeleteArchiveOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteArchiveRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeleteArchiveOutput)
-	return ret0, ret1
-}
-
-// DeleteArchiveRequest indicates an expected call of DeleteArchiveRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteArchiveRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteArchiveRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteArchiveRequest), arg0)
-}
-
-// DeleteArchiveWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeleteArchiveWithContext(arg0 context.Context, arg1 *eventbridge.DeleteArchiveInput, arg2 ...request.Option) (*eventbridge.DeleteArchiveOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteArchiveWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeleteArchiveOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteArchiveWithContext indicates an expected call of DeleteArchiveWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteArchiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteArchiveWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteArchiveWithContext), varargs...)
-}
-
-// DeleteConnection mocks base method.
-func (m *MockEventBridgeAPI) DeleteConnection(arg0 *eventbridge.DeleteConnectionInput) (*eventbridge.DeleteConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteConnection", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeleteConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteConnection indicates an expected call of DeleteConnection.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConnection", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteConnection), arg0)
-}
-
-// DeleteConnectionRequest mocks base method.
-func (m *MockEventBridgeAPI) DeleteConnectionRequest(arg0 *eventbridge.DeleteConnectionInput) (*request.Request, *eventbridge.DeleteConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeleteConnectionOutput)
-	return ret0, ret1
-}
-
-// DeleteConnectionRequest indicates an expected call of DeleteConnectionRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConnectionRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteConnectionRequest), arg0)
-}
-
-// DeleteConnectionWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeleteConnectionWithContext(arg0 context.Context, arg1 *eventbridge.DeleteConnectionInput, arg2 ...request.Option) (*eventbridge.DeleteConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeleteConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteConnectionWithContext indicates an expected call of DeleteConnectionWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConnectionWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteConnectionWithContext), varargs...)
-}
-
-// DeleteEndpoint mocks base method.
-func (m *MockEventBridgeAPI) DeleteEndpoint(arg0 *eventbridge.DeleteEndpointInput) (*eventbridge.DeleteEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteEndpoint", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeleteEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteEndpoint indicates an expected call of DeleteEndpoint.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEndpoint", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteEndpoint), arg0)
-}
-
-// DeleteEndpointRequest mocks base method.
-func (m *MockEventBridgeAPI) DeleteEndpointRequest(arg0 *eventbridge.DeleteEndpointInput) (*request.Request, *eventbridge.DeleteEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeleteEndpointOutput)
-	return ret0, ret1
-}
-
-// DeleteEndpointRequest indicates an expected call of DeleteEndpointRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEndpointRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteEndpointRequest), arg0)
-}
-
-// DeleteEndpointWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeleteEndpointWithContext(arg0 context.Context, arg1 *eventbridge.DeleteEndpointInput, arg2 ...request.Option) (*eventbridge.DeleteEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeleteEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteEndpointWithContext indicates an expected call of DeleteEndpointWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEndpointWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteEndpointWithContext), varargs...)
-}
-
-// DeleteEventBus mocks base method.
-func (m *MockEventBridgeAPI) DeleteEventBus(arg0 *eventbridge.DeleteEventBusInput) (*eventbridge.DeleteEventBusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteEventBus", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeleteEventBusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteEventBus indicates an expected call of DeleteEventBus.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteEventBus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventBus", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteEventBus), arg0)
-}
-
-// DeleteEventBusRequest mocks base method.
-func (m *MockEventBridgeAPI) DeleteEventBusRequest(arg0 *eventbridge.DeleteEventBusInput) (*request.Request, *eventbridge.DeleteEventBusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteEventBusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeleteEventBusOutput)
-	return ret0, ret1
-}
-
-// DeleteEventBusRequest indicates an expected call of DeleteEventBusRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteEventBusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventBusRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteEventBusRequest), arg0)
-}
-
-// DeleteEventBusWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeleteEventBusWithContext(arg0 context.Context, arg1 *eventbridge.DeleteEventBusInput, arg2 ...request.Option) (*eventbridge.DeleteEventBusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteEventBusWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeleteEventBusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteEventBusWithContext indicates an expected call of DeleteEventBusWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteEventBusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEventBusWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteEventBusWithContext), varargs...)
-}
-
-// DeletePartnerEventSource mocks base method.
-func (m *MockEventBridgeAPI) DeletePartnerEventSource(arg0 *eventbridge.DeletePartnerEventSourceInput) (*eventbridge.DeletePartnerEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeletePartnerEventSource", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeletePartnerEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeletePartnerEventSource indicates an expected call of DeletePartnerEventSource.
-func (mr *MockEventBridgeAPIMockRecorder) DeletePartnerEventSource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePartnerEventSource", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeletePartnerEventSource), arg0)
-}
-
-// DeletePartnerEventSourceRequest mocks base method.
-func (m *MockEventBridgeAPI) DeletePartnerEventSourceRequest(arg0 *eventbridge.DeletePartnerEventSourceInput) (*request.Request, *eventbridge.DeletePartnerEventSourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeletePartnerEventSourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeletePartnerEventSourceOutput)
-	return ret0, ret1
-}
-
-// DeletePartnerEventSourceRequest indicates an expected call of DeletePartnerEventSourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeletePartnerEventSourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePartnerEventSourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeletePartnerEventSourceRequest), arg0)
-}
-
-// DeletePartnerEventSourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeletePartnerEventSourceWithContext(arg0 context.Context, arg1 *eventbridge.DeletePartnerEventSourceInput, arg2 ...request.Option) (*eventbridge.DeletePartnerEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeletePartnerEventSourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeletePartnerEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeletePartnerEventSourceWithContext indicates an expected call of DeletePartnerEventSourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeletePartnerEventSourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePartnerEventSourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeletePartnerEventSourceWithContext), varargs...)
-}
-
-// DeleteRule mocks base method.
-func (m *MockEventBridgeAPI) DeleteRule(arg0 *eventbridge.DeleteRuleInput) (*eventbridge.DeleteRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteRule", arg0)
-	ret0, _ := ret[0].(*eventbridge.DeleteRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteRule indicates an expected call of DeleteRule.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteRule), arg0)
-}
-
-// DeleteRuleRequest mocks base method.
-func (m *MockEventBridgeAPI) DeleteRuleRequest(arg0 *eventbridge.DeleteRuleInput) (*request.Request, *eventbridge.DeleteRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DeleteRuleOutput)
-	return ret0, ret1
-}
-
-// DeleteRuleRequest indicates an expected call of DeleteRuleRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteRuleRequest), arg0)
-}
-
-// DeleteRuleWithContext mocks base method.
-func (m *MockEventBridgeAPI) DeleteRuleWithContext(arg0 context.Context, arg1 *eventbridge.DeleteRuleInput, arg2 ...request.Option) (*eventbridge.DeleteRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DeleteRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteRuleWithContext indicates an expected call of DeleteRuleWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DeleteRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteRuleWithContext), varargs...)
-}
-
-// DescribeApiDestination mocks base method.
-func (m *MockEventBridgeAPI) DescribeApiDestination(arg0 *eventbridge.DescribeApiDestinationInput) (*eventbridge.DescribeApiDestinationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeApiDestination", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribeApiDestinationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeApiDestination indicates an expected call of DescribeApiDestination.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeApiDestination(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeApiDestination", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeApiDestination), arg0)
-}
-
-// DescribeApiDestinationRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribeApiDestinationRequest(arg0 *eventbridge.DescribeApiDestinationInput) (*request.Request, *eventbridge.DescribeApiDestinationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeApiDestinationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribeApiDestinationOutput)
-	return ret0, ret1
-}
-
-// DescribeApiDestinationRequest indicates an expected call of DescribeApiDestinationRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeApiDestinationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeApiDestinationRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeApiDestinationRequest), arg0)
-}
-
-// DescribeApiDestinationWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribeApiDestinationWithContext(arg0 context.Context, arg1 *eventbridge.DescribeApiDestinationInput, arg2 ...request.Option) (*eventbridge.DescribeApiDestinationOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeApiDestinationWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribeApiDestinationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeApiDestinationWithContext indicates an expected call of DescribeApiDestinationWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeApiDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeApiDestinationWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeApiDestinationWithContext), varargs...)
-}
-
-// DescribeArchive mocks base method.
-func (m *MockEventBridgeAPI) DescribeArchive(arg0 *eventbridge.DescribeArchiveInput) (*eventbridge.DescribeArchiveOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeArchive", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribeArchiveOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeArchive indicates an expected call of DescribeArchive.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeArchive(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeArchive", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeArchive), arg0)
-}
-
-// DescribeArchiveRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribeArchiveRequest(arg0 *eventbridge.DescribeArchiveInput) (*request.Request, *eventbridge.DescribeArchiveOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeArchiveRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribeArchiveOutput)
-	return ret0, ret1
-}
-
-// DescribeArchiveRequest indicates an expected call of DescribeArchiveRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeArchiveRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeArchiveRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeArchiveRequest), arg0)
-}
-
-// DescribeArchiveWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribeArchiveWithContext(arg0 context.Context, arg1 *eventbridge.DescribeArchiveInput, arg2 ...request.Option) (*eventbridge.DescribeArchiveOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeArchiveWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribeArchiveOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeArchiveWithContext indicates an expected call of DescribeArchiveWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeArchiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeArchiveWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeArchiveWithContext), varargs...)
-}
-
-// DescribeConnection mocks base method.
-func (m *MockEventBridgeAPI) DescribeConnection(arg0 *eventbridge.DescribeConnectionInput) (*eventbridge.DescribeConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeConnection", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribeConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeConnection indicates an expected call of DescribeConnection.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConnection", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeConnection), arg0)
-}
-
-// DescribeConnectionRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribeConnectionRequest(arg0 *eventbridge.DescribeConnectionInput) (*request.Request, *eventbridge.DescribeConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribeConnectionOutput)
-	return ret0, ret1
-}
-
-// DescribeConnectionRequest indicates an expected call of DescribeConnectionRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConnectionRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeConnectionRequest), arg0)
-}
-
-// DescribeConnectionWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribeConnectionWithContext(arg0 context.Context, arg1 *eventbridge.DescribeConnectionInput, arg2 ...request.Option) (*eventbridge.DescribeConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribeConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeConnectionWithContext indicates an expected call of DescribeConnectionWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConnectionWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeConnectionWithContext), varargs...)
-}
-
-// DescribeEndpoint mocks base method.
-func (m *MockEventBridgeAPI) DescribeEndpoint(arg0 *eventbridge.DescribeEndpointInput) (*eventbridge.DescribeEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEndpoint", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribeEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeEndpoint indicates an expected call of DescribeEndpoint.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEndpoint", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEndpoint), arg0)
-}
-
-// DescribeEndpointRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribeEndpointRequest(arg0 *eventbridge.DescribeEndpointInput) (*request.Request, *eventbridge.DescribeEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribeEndpointOutput)
-	return ret0, ret1
-}
-
-// DescribeEndpointRequest indicates an expected call of DescribeEndpointRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEndpointRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEndpointRequest), arg0)
-}
-
-// DescribeEndpointWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribeEndpointWithContext(arg0 context.Context, arg1 *eventbridge.DescribeEndpointInput, arg2 ...request.Option) (*eventbridge.DescribeEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribeEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeEndpointWithContext indicates an expected call of DescribeEndpointWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEndpointWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEndpointWithContext), varargs...)
-}
-
-// DescribeEventBus mocks base method.
-func (m *MockEventBridgeAPI) DescribeEventBus(arg0 *eventbridge.DescribeEventBusInput) (*eventbridge.DescribeEventBusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEventBus", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribeEventBusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeEventBus indicates an expected call of DescribeEventBus.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEventBus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventBus", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEventBus), arg0)
-}
-
-// DescribeEventBusRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribeEventBusRequest(arg0 *eventbridge.DescribeEventBusInput) (*request.Request, *eventbridge.DescribeEventBusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEventBusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribeEventBusOutput)
-	return ret0, ret1
-}
-
-// DescribeEventBusRequest indicates an expected call of DescribeEventBusRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEventBusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventBusRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEventBusRequest), arg0)
-}
-
-// DescribeEventBusWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribeEventBusWithContext(arg0 context.Context, arg1 *eventbridge.DescribeEventBusInput, arg2 ...request.Option) (*eventbridge.DescribeEventBusOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeEventBusWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribeEventBusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeEventBusWithContext indicates an expected call of DescribeEventBusWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEventBusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventBusWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEventBusWithContext), varargs...)
-}
-
-// DescribeEventSource mocks base method.
-func (m *MockEventBridgeAPI) DescribeEventSource(arg0 *eventbridge.DescribeEventSourceInput) (*eventbridge.DescribeEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEventSource", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribeEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeEventSource indicates an expected call of DescribeEventSource.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEventSource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventSource", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEventSource), arg0)
-}
-
-// DescribeEventSourceRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribeEventSourceRequest(arg0 *eventbridge.DescribeEventSourceInput) (*request.Request, *eventbridge.DescribeEventSourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeEventSourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribeEventSourceOutput)
-	return ret0, ret1
-}
-
-// DescribeEventSourceRequest indicates an expected call of DescribeEventSourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEventSourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventSourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEventSourceRequest), arg0)
-}
-
-// DescribeEventSourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribeEventSourceWithContext(arg0 context.Context, arg1 *eventbridge.DescribeEventSourceInput, arg2 ...request.Option) (*eventbridge.DescribeEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeEventSourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribeEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeEventSourceWithContext indicates an expected call of DescribeEventSourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeEventSourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventSourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeEventSourceWithContext), varargs...)
-}
-
-// DescribePartnerEventSource mocks base method.
-func (m *MockEventBridgeAPI) DescribePartnerEventSource(arg0 *eventbridge.DescribePartnerEventSourceInput) (*eventbridge.DescribePartnerEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePartnerEventSource", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribePartnerEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePartnerEventSource indicates an expected call of DescribePartnerEventSource.
-func (mr *MockEventBridgeAPIMockRecorder) DescribePartnerEventSource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePartnerEventSource", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribePartnerEventSource), arg0)
-}
-
-// DescribePartnerEventSourceRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribePartnerEventSourceRequest(arg0 *eventbridge.DescribePartnerEventSourceInput) (*request.Request, *eventbridge.DescribePartnerEventSourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribePartnerEventSourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribePartnerEventSourceOutput)
-	return ret0, ret1
-}
-
-// DescribePartnerEventSourceRequest indicates an expected call of DescribePartnerEventSourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribePartnerEventSourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePartnerEventSourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribePartnerEventSourceRequest), arg0)
-}
-
-// DescribePartnerEventSourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribePartnerEventSourceWithContext(arg0 context.Context, arg1 *eventbridge.DescribePartnerEventSourceInput, arg2 ...request.Option) (*eventbridge.DescribePartnerEventSourceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribePartnerEventSourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribePartnerEventSourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribePartnerEventSourceWithContext indicates an expected call of DescribePartnerEventSourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribePartnerEventSourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePartnerEventSourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribePartnerEventSourceWithContext), varargs...)
-}
-
-// DescribeReplay mocks base method.
-func (m *MockEventBridgeAPI) DescribeReplay(arg0 *eventbridge.DescribeReplayInput) (*eventbridge.DescribeReplayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReplay", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribeReplayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReplay indicates an expected call of DescribeReplay.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeReplay(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplay", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeReplay), arg0)
-}
-
-// DescribeReplayRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribeReplayRequest(arg0 *eventbridge.DescribeReplayInput) (*request.Request, *eventbridge.DescribeReplayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeReplayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribeReplayOutput)
-	return ret0, ret1
-}
-
-// DescribeReplayRequest indicates an expected call of DescribeReplayRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeReplayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplayRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeReplayRequest), arg0)
-}
-
-// DescribeReplayWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribeReplayWithContext(arg0 context.Context, arg1 *eventbridge.DescribeReplayInput, arg2 ...request.Option) (*eventbridge.DescribeReplayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeReplayWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribeReplayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeReplayWithContext indicates an expected call of DescribeReplayWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeReplayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplayWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeReplayWithContext), varargs...)
-}
-
-// DescribeRule mocks base method.
-func (m *MockEventBridgeAPI) DescribeRule(arg0 *eventbridge.DescribeRuleInput) (*eventbridge.DescribeRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRule", arg0)
-	ret0, _ := ret[0].(*eventbridge.DescribeRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeRule indicates an expected call of DescribeRule.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeRule), arg0)
-}
-
-// DescribeRuleRequest mocks base method.
-func (m *MockEventBridgeAPI) DescribeRuleRequest(arg0 *eventbridge.DescribeRuleInput) (*request.Request, *eventbridge.DescribeRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DescribeRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DescribeRuleOutput)
-	return ret0, ret1
-}
-
-// DescribeRuleRequest indicates an expected call of DescribeRuleRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRuleRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeRuleRequest), arg0)
-}
-
-// DescribeRuleWithContext mocks base method.
-func (m *MockEventBridgeAPI) DescribeRuleWithContext(arg0 context.Context, arg1 *eventbridge.DescribeRuleInput, arg2 ...request.Option) (*eventbridge.DescribeRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DescribeRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DescribeRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DescribeRuleWithContext indicates an expected call of DescribeRuleWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DescribeRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRuleWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeRuleWithContext), varargs...)
-}
-
-// DisableRule mocks base method.
-func (m *MockEventBridgeAPI) DisableRule(arg0 *eventbridge.DisableRuleInput) (*eventbridge.DisableRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableRule", arg0)
-	ret0, _ := ret[0].(*eventbridge.DisableRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableRule indicates an expected call of DisableRule.
-func (mr *MockEventBridgeAPIMockRecorder) DisableRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).DisableRule), arg0)
-}
-
-// DisableRuleRequest mocks base method.
-func (m *MockEventBridgeAPI) DisableRuleRequest(arg0 *eventbridge.DisableRuleInput) (*request.Request, *eventbridge.DisableRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DisableRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.DisableRuleOutput)
-	return ret0, ret1
-}
-
-// DisableRuleRequest indicates an expected call of DisableRuleRequest.
-func (mr *MockEventBridgeAPIMockRecorder) DisableRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableRuleRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).DisableRuleRequest), arg0)
-}
-
-// DisableRuleWithContext mocks base method.
-func (m *MockEventBridgeAPI) DisableRuleWithContext(arg0 context.Context, arg1 *eventbridge.DisableRuleInput, arg2 ...request.Option) (*eventbridge.DisableRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DisableRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.DisableRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DisableRuleWithContext indicates an expected call of DisableRuleWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) DisableRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableRuleWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).DisableRuleWithContext), varargs...)
-}
-
-// EnableRule mocks base method.
-func (m *MockEventBridgeAPI) EnableRule(arg0 *eventbridge.EnableRuleInput) (*eventbridge.EnableRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableRule", arg0)
-	ret0, _ := ret[0].(*eventbridge.EnableRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableRule indicates an expected call of EnableRule.
-func (mr *MockEventBridgeAPIMockRecorder) EnableRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).EnableRule), arg0)
-}
-
-// EnableRuleRequest mocks base method.
-func (m *MockEventBridgeAPI) EnableRuleRequest(arg0 *eventbridge.EnableRuleInput) (*request.Request, *eventbridge.EnableRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EnableRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.EnableRuleOutput)
-	return ret0, ret1
-}
-
-// EnableRuleRequest indicates an expected call of EnableRuleRequest.
-func (mr *MockEventBridgeAPIMockRecorder) EnableRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRuleRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).EnableRuleRequest), arg0)
-}
-
-// EnableRuleWithContext mocks base method.
-func (m *MockEventBridgeAPI) EnableRuleWithContext(arg0 context.Context, arg1 *eventbridge.EnableRuleInput, arg2 ...request.Option) (*eventbridge.EnableRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EnableRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.EnableRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EnableRuleWithContext indicates an expected call of EnableRuleWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) EnableRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRuleWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).EnableRuleWithContext), varargs...)
-}
-
-// ListApiDestinations mocks base method.
-func (m *MockEventBridgeAPI) ListApiDestinations(arg0 *eventbridge.ListApiDestinationsInput) (*eventbridge.ListApiDestinationsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListApiDestinations", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListApiDestinationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListApiDestinations indicates an expected call of ListApiDestinations.
-func (mr *MockEventBridgeAPIMockRecorder) ListApiDestinations(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListApiDestinations", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListApiDestinations), arg0)
-}
-
-// ListApiDestinationsRequest mocks base method.
-func (m *MockEventBridgeAPI) ListApiDestinationsRequest(arg0 *eventbridge.ListApiDestinationsInput) (*request.Request, *eventbridge.ListApiDestinationsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListApiDestinationsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListApiDestinationsOutput)
-	return ret0, ret1
-}
-
-// ListApiDestinationsRequest indicates an expected call of ListApiDestinationsRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListApiDestinationsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListApiDestinationsRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListApiDestinationsRequest), arg0)
-}
-
-// ListApiDestinationsWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListApiDestinationsWithContext(arg0 context.Context, arg1 *eventbridge.ListApiDestinationsInput, arg2 ...request.Option) (*eventbridge.ListApiDestinationsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListApiDestinationsWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListApiDestinationsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListApiDestinationsWithContext indicates an expected call of ListApiDestinationsWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListApiDestinationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListApiDestinationsWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListApiDestinationsWithContext), varargs...)
-}
-
-// ListArchives mocks base method.
-func (m *MockEventBridgeAPI) ListArchives(arg0 *eventbridge.ListArchivesInput) (*eventbridge.ListArchivesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListArchives", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListArchivesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListArchives indicates an expected call of ListArchives.
-func (mr *MockEventBridgeAPIMockRecorder) ListArchives(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArchives", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListArchives), arg0)
-}
-
-// ListArchivesRequest mocks base method.
-func (m *MockEventBridgeAPI) ListArchivesRequest(arg0 *eventbridge.ListArchivesInput) (*request.Request, *eventbridge.ListArchivesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListArchivesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListArchivesOutput)
-	return ret0, ret1
-}
-
-// ListArchivesRequest indicates an expected call of ListArchivesRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListArchivesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArchivesRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListArchivesRequest), arg0)
-}
-
-// ListArchivesWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListArchivesWithContext(arg0 context.Context, arg1 *eventbridge.ListArchivesInput, arg2 ...request.Option) (*eventbridge.ListArchivesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListArchivesWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListArchivesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListArchivesWithContext indicates an expected call of ListArchivesWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListArchivesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArchivesWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListArchivesWithContext), varargs...)
-}
-
-// ListConnections mocks base method.
-func (m *MockEventBridgeAPI) ListConnections(arg0 *eventbridge.ListConnectionsInput) (*eventbridge.ListConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListConnections", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListConnections indicates an expected call of ListConnections.
-func (mr *MockEventBridgeAPIMockRecorder) ListConnections(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConnections", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListConnections), arg0)
-}
-
-// ListConnectionsRequest mocks base method.
-func (m *MockEventBridgeAPI) ListConnectionsRequest(arg0 *eventbridge.ListConnectionsInput) (*request.Request, *eventbridge.ListConnectionsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListConnectionsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListConnectionsOutput)
-	return ret0, ret1
-}
-
-// ListConnectionsRequest indicates an expected call of ListConnectionsRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListConnectionsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConnectionsRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListConnectionsRequest), arg0)
-}
-
-// ListConnectionsWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListConnectionsWithContext(arg0 context.Context, arg1 *eventbridge.ListConnectionsInput, arg2 ...request.Option) (*eventbridge.ListConnectionsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListConnectionsWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListConnectionsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListConnectionsWithContext indicates an expected call of ListConnectionsWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConnectionsWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListConnectionsWithContext), varargs...)
-}
-
-// ListEndpoints mocks base method.
-func (m *MockEventBridgeAPI) ListEndpoints(arg0 *eventbridge.ListEndpointsInput) (*eventbridge.ListEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListEndpoints", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListEndpoints indicates an expected call of ListEndpoints.
-func (mr *MockEventBridgeAPIMockRecorder) ListEndpoints(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpoints", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEndpoints), arg0)
-}
-
-// ListEndpointsRequest mocks base method.
-func (m *MockEventBridgeAPI) ListEndpointsRequest(arg0 *eventbridge.ListEndpointsInput) (*request.Request, *eventbridge.ListEndpointsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListEndpointsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListEndpointsOutput)
-	return ret0, ret1
-}
-
-// ListEndpointsRequest indicates an expected call of ListEndpointsRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListEndpointsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEndpointsRequest), arg0)
-}
-
-// ListEndpointsWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListEndpointsWithContext(arg0 context.Context, arg1 *eventbridge.ListEndpointsInput, arg2 ...request.Option) (*eventbridge.ListEndpointsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListEndpointsWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListEndpointsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListEndpointsWithContext indicates an expected call of ListEndpointsWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEndpointsWithContext), varargs...)
-}
-
-// ListEventBuses mocks base method.
-func (m *MockEventBridgeAPI) ListEventBuses(arg0 *eventbridge.ListEventBusesInput) (*eventbridge.ListEventBusesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListEventBuses", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListEventBusesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListEventBuses indicates an expected call of ListEventBuses.
-func (mr *MockEventBridgeAPIMockRecorder) ListEventBuses(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventBuses", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEventBuses), arg0)
-}
-
-// ListEventBusesRequest mocks base method.
-func (m *MockEventBridgeAPI) ListEventBusesRequest(arg0 *eventbridge.ListEventBusesInput) (*request.Request, *eventbridge.ListEventBusesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListEventBusesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListEventBusesOutput)
-	return ret0, ret1
-}
-
-// ListEventBusesRequest indicates an expected call of ListEventBusesRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListEventBusesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventBusesRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEventBusesRequest), arg0)
-}
-
-// ListEventBusesWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListEventBusesWithContext(arg0 context.Context, arg1 *eventbridge.ListEventBusesInput, arg2 ...request.Option) (*eventbridge.ListEventBusesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListEventBusesWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListEventBusesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListEventBusesWithContext indicates an expected call of ListEventBusesWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListEventBusesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventBusesWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEventBusesWithContext), varargs...)
-}
-
-// ListEventSources mocks base method.
-func (m *MockEventBridgeAPI) ListEventSources(arg0 *eventbridge.ListEventSourcesInput) (*eventbridge.ListEventSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListEventSources", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListEventSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListEventSources indicates an expected call of ListEventSources.
-func (mr *MockEventBridgeAPIMockRecorder) ListEventSources(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventSources", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEventSources), arg0)
-}
-
-// ListEventSourcesRequest mocks base method.
-func (m *MockEventBridgeAPI) ListEventSourcesRequest(arg0 *eventbridge.ListEventSourcesInput) (*request.Request, *eventbridge.ListEventSourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListEventSourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListEventSourcesOutput)
-	return ret0, ret1
-}
-
-// ListEventSourcesRequest indicates an expected call of ListEventSourcesRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListEventSourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventSourcesRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEventSourcesRequest), arg0)
-}
-
-// ListEventSourcesWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListEventSourcesWithContext(arg0 context.Context, arg1 *eventbridge.ListEventSourcesInput, arg2 ...request.Option) (*eventbridge.ListEventSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListEventSourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListEventSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListEventSourcesWithContext indicates an expected call of ListEventSourcesWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListEventSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventSourcesWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListEventSourcesWithContext), varargs...)
-}
-
-// ListPartnerEventSourceAccounts mocks base method.
-func (m *MockEventBridgeAPI) ListPartnerEventSourceAccounts(arg0 *eventbridge.ListPartnerEventSourceAccountsInput) (*eventbridge.ListPartnerEventSourceAccountsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListPartnerEventSourceAccounts", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListPartnerEventSourceAccountsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListPartnerEventSourceAccounts indicates an expected call of ListPartnerEventSourceAccounts.
-func (mr *MockEventBridgeAPIMockRecorder) ListPartnerEventSourceAccounts(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartnerEventSourceAccounts", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListPartnerEventSourceAccounts), arg0)
-}
-
-// ListPartnerEventSourceAccountsRequest mocks base method.
-func (m *MockEventBridgeAPI) ListPartnerEventSourceAccountsRequest(arg0 *eventbridge.ListPartnerEventSourceAccountsInput) (*request.Request, *eventbridge.ListPartnerEventSourceAccountsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListPartnerEventSourceAccountsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListPartnerEventSourceAccountsOutput)
-	return ret0, ret1
-}
-
-// ListPartnerEventSourceAccountsRequest indicates an expected call of ListPartnerEventSourceAccountsRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListPartnerEventSourceAccountsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartnerEventSourceAccountsRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListPartnerEventSourceAccountsRequest), arg0)
-}
-
-// ListPartnerEventSourceAccountsWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListPartnerEventSourceAccountsWithContext(arg0 context.Context, arg1 *eventbridge.ListPartnerEventSourceAccountsInput, arg2 ...request.Option) (*eventbridge.ListPartnerEventSourceAccountsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListPartnerEventSourceAccountsWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListPartnerEventSourceAccountsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListPartnerEventSourceAccountsWithContext indicates an expected call of ListPartnerEventSourceAccountsWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListPartnerEventSourceAccountsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartnerEventSourceAccountsWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListPartnerEventSourceAccountsWithContext), varargs...)
-}
-
-// ListPartnerEventSources mocks base method.
-func (m *MockEventBridgeAPI) ListPartnerEventSources(arg0 *eventbridge.ListPartnerEventSourcesInput) (*eventbridge.ListPartnerEventSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListPartnerEventSources", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListPartnerEventSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListPartnerEventSources indicates an expected call of ListPartnerEventSources.
-func (mr *MockEventBridgeAPIMockRecorder) ListPartnerEventSources(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartnerEventSources", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListPartnerEventSources), arg0)
-}
-
-// ListPartnerEventSourcesRequest mocks base method.
-func (m *MockEventBridgeAPI) ListPartnerEventSourcesRequest(arg0 *eventbridge.ListPartnerEventSourcesInput) (*request.Request, *eventbridge.ListPartnerEventSourcesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListPartnerEventSourcesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListPartnerEventSourcesOutput)
-	return ret0, ret1
-}
-
-// ListPartnerEventSourcesRequest indicates an expected call of ListPartnerEventSourcesRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListPartnerEventSourcesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartnerEventSourcesRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListPartnerEventSourcesRequest), arg0)
-}
-
-// ListPartnerEventSourcesWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListPartnerEventSourcesWithContext(arg0 context.Context, arg1 *eventbridge.ListPartnerEventSourcesInput, arg2 ...request.Option) (*eventbridge.ListPartnerEventSourcesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListPartnerEventSourcesWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListPartnerEventSourcesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListPartnerEventSourcesWithContext indicates an expected call of ListPartnerEventSourcesWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListPartnerEventSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartnerEventSourcesWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListPartnerEventSourcesWithContext), varargs...)
-}
-
-// ListReplays mocks base method.
-func (m *MockEventBridgeAPI) ListReplays(arg0 *eventbridge.ListReplaysInput) (*eventbridge.ListReplaysOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListReplays", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListReplaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListReplays indicates an expected call of ListReplays.
-func (mr *MockEventBridgeAPIMockRecorder) ListReplays(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReplays", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListReplays), arg0)
-}
-
-// ListReplaysRequest mocks base method.
-func (m *MockEventBridgeAPI) ListReplaysRequest(arg0 *eventbridge.ListReplaysInput) (*request.Request, *eventbridge.ListReplaysOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListReplaysRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListReplaysOutput)
-	return ret0, ret1
-}
-
-// ListReplaysRequest indicates an expected call of ListReplaysRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListReplaysRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReplaysRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListReplaysRequest), arg0)
-}
-
-// ListReplaysWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListReplaysWithContext(arg0 context.Context, arg1 *eventbridge.ListReplaysInput, arg2 ...request.Option) (*eventbridge.ListReplaysOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListReplaysWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListReplaysOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListReplaysWithContext indicates an expected call of ListReplaysWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListReplaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReplaysWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListReplaysWithContext), varargs...)
-}
-
-// ListRuleNamesByTarget mocks base method.
-func (m *MockEventBridgeAPI) ListRuleNamesByTarget(arg0 *eventbridge.ListRuleNamesByTargetInput) (*eventbridge.ListRuleNamesByTargetOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListRuleNamesByTarget", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListRuleNamesByTargetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListRuleNamesByTarget indicates an expected call of ListRuleNamesByTarget.
-func (mr *MockEventBridgeAPIMockRecorder) ListRuleNamesByTarget(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRuleNamesByTarget", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListRuleNamesByTarget), arg0)
-}
-
-// ListRuleNamesByTargetRequest mocks base method.
-func (m *MockEventBridgeAPI) ListRuleNamesByTargetRequest(arg0 *eventbridge.ListRuleNamesByTargetInput) (*request.Request, *eventbridge.ListRuleNamesByTargetOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListRuleNamesByTargetRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListRuleNamesByTargetOutput)
-	return ret0, ret1
-}
-
-// ListRuleNamesByTargetRequest indicates an expected call of ListRuleNamesByTargetRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListRuleNamesByTargetRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRuleNamesByTargetRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListRuleNamesByTargetRequest), arg0)
-}
-
-// ListRuleNamesByTargetWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListRuleNamesByTargetWithContext(arg0 context.Context, arg1 *eventbridge.ListRuleNamesByTargetInput, arg2 ...request.Option) (*eventbridge.ListRuleNamesByTargetOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListRuleNamesByTargetWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListRuleNamesByTargetOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListRuleNamesByTargetWithContext indicates an expected call of ListRuleNamesByTargetWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListRuleNamesByTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRuleNamesByTargetWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListRuleNamesByTargetWithContext), varargs...)
-}
-
-// ListRules mocks base method.
-func (m *MockEventBridgeAPI) ListRules(arg0 *eventbridge.ListRulesInput) (*eventbridge.ListRulesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListRules", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListRules indicates an expected call of ListRules.
-func (mr *MockEventBridgeAPIMockRecorder) ListRules(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRules", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListRules), arg0)
-}
-
-// ListRulesRequest mocks base method.
-func (m *MockEventBridgeAPI) ListRulesRequest(arg0 *eventbridge.ListRulesInput) (*request.Request, *eventbridge.ListRulesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListRulesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListRulesOutput)
-	return ret0, ret1
-}
-
-// ListRulesRequest indicates an expected call of ListRulesRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListRulesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRulesRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListRulesRequest), arg0)
-}
-
-// ListRulesWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListRulesWithContext(arg0 context.Context, arg1 *eventbridge.ListRulesInput, arg2 ...request.Option) (*eventbridge.ListRulesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListRulesWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListRulesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListRulesWithContext indicates an expected call of ListRulesWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRulesWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListRulesWithContext), varargs...)
-}
-
-// ListTagsForResource mocks base method.
-func (m *MockEventBridgeAPI) ListTagsForResource(arg0 *eventbridge.ListTagsForResourceInput) (*eventbridge.ListTagsForResourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListTagsForResourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListTagsForResource indicates an expected call of ListTagsForResource.
-func (mr *MockEventBridgeAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListTagsForResource), arg0)
-}
-
-// ListTagsForResourceRequest mocks base method.
-func (m *MockEventBridgeAPI) ListTagsForResourceRequest(arg0 *eventbridge.ListTagsForResourceInput) (*request.Request, *eventbridge.ListTagsForResourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListTagsForResourceOutput)
-	return ret0, ret1
-}
-
-// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListTagsForResourceRequest), arg0)
-}
-
-// ListTagsForResourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *eventbridge.ListTagsForResourceInput, arg2 ...request.Option) (*eventbridge.ListTagsForResourceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListTagsForResourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListTagsForResourceWithContext), varargs...)
-}
-
-// ListTargetsByRule mocks base method.
-func (m *MockEventBridgeAPI) ListTargetsByRule(arg0 *eventbridge.ListTargetsByRuleInput) (*eventbridge.ListTargetsByRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListTargetsByRule", arg0)
-	ret0, _ := ret[0].(*eventbridge.ListTargetsByRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListTargetsByRule indicates an expected call of ListTargetsByRule.
-func (mr *MockEventBridgeAPIMockRecorder) ListTargetsByRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTargetsByRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListTargetsByRule), arg0)
-}
-
-// ListTargetsByRuleRequest mocks base method.
-func (m *MockEventBridgeAPI) ListTargetsByRuleRequest(arg0 *eventbridge.ListTargetsByRuleInput) (*request.Request, *eventbridge.ListTargetsByRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListTargetsByRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.ListTargetsByRuleOutput)
-	return ret0, ret1
-}
-
-// ListTargetsByRuleRequest indicates an expected call of ListTargetsByRuleRequest.
-func (mr *MockEventBridgeAPIMockRecorder) ListTargetsByRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTargetsByRuleRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListTargetsByRuleRequest), arg0)
-}
-
-// ListTargetsByRuleWithContext mocks base method.
-func (m *MockEventBridgeAPI) ListTargetsByRuleWithContext(arg0 context.Context, arg1 *eventbridge.ListTargetsByRuleInput, arg2 ...request.Option) (*eventbridge.ListTargetsByRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListTargetsByRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.ListTargetsByRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListTargetsByRuleWithContext indicates an expected call of ListTargetsByRuleWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) ListTargetsByRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTargetsByRuleWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListTargetsByRuleWithContext), varargs...)
-}
-
-// PutEvents mocks base method.
-func (m *MockEventBridgeAPI) PutEvents(arg0 *eventbridge.PutEventsInput) (*eventbridge.PutEventsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutEvents", arg0)
-	ret0, _ := ret[0].(*eventbridge.PutEventsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutEvents indicates an expected call of PutEvents.
-func (mr *MockEventBridgeAPIMockRecorder) PutEvents(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEvents", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutEvents), arg0)
-}
-
-// PutEventsRequest mocks base method.
-func (m *MockEventBridgeAPI) PutEventsRequest(arg0 *eventbridge.PutEventsInput) (*request.Request, *eventbridge.PutEventsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutEventsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.PutEventsOutput)
-	return ret0, ret1
-}
-
-// PutEventsRequest indicates an expected call of PutEventsRequest.
-func (mr *MockEventBridgeAPIMockRecorder) PutEventsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEventsRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutEventsRequest), arg0)
-}
-
-// PutEventsWithContext mocks base method.
-func (m *MockEventBridgeAPI) PutEventsWithContext(arg0 context.Context, arg1 *eventbridge.PutEventsInput, arg2 ...request.Option) (*eventbridge.PutEventsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutEventsWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.PutEventsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutEventsWithContext indicates an expected call of PutEventsWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) PutEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEventsWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutEventsWithContext), varargs...)
-}
-
-// PutPartnerEvents mocks base method.
-func (m *MockEventBridgeAPI) PutPartnerEvents(arg0 *eventbridge.PutPartnerEventsInput) (*eventbridge.PutPartnerEventsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutPartnerEvents", arg0)
-	ret0, _ := ret[0].(*eventbridge.PutPartnerEventsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutPartnerEvents indicates an expected call of PutPartnerEvents.
-func (mr *MockEventBridgeAPIMockRecorder) PutPartnerEvents(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPartnerEvents", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutPartnerEvents), arg0)
-}
-
-// PutPartnerEventsRequest mocks base method.
-func (m *MockEventBridgeAPI) PutPartnerEventsRequest(arg0 *eventbridge.PutPartnerEventsInput) (*request.Request, *eventbridge.PutPartnerEventsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutPartnerEventsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.PutPartnerEventsOutput)
-	return ret0, ret1
-}
-
-// PutPartnerEventsRequest indicates an expected call of PutPartnerEventsRequest.
-func (mr *MockEventBridgeAPIMockRecorder) PutPartnerEventsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPartnerEventsRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutPartnerEventsRequest), arg0)
-}
-
-// PutPartnerEventsWithContext mocks base method.
-func (m *MockEventBridgeAPI) PutPartnerEventsWithContext(arg0 context.Context, arg1 *eventbridge.PutPartnerEventsInput, arg2 ...request.Option) (*eventbridge.PutPartnerEventsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutPartnerEventsWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.PutPartnerEventsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutPartnerEventsWithContext indicates an expected call of PutPartnerEventsWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) PutPartnerEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPartnerEventsWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutPartnerEventsWithContext), varargs...)
-}
-
-// PutPermission mocks base method.
-func (m *MockEventBridgeAPI) PutPermission(arg0 *eventbridge.PutPermissionInput) (*eventbridge.PutPermissionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutPermission", arg0)
-	ret0, _ := ret[0].(*eventbridge.PutPermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutPermission indicates an expected call of PutPermission.
-func (mr *MockEventBridgeAPIMockRecorder) PutPermission(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPermission", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutPermission), arg0)
-}
-
-// PutPermissionRequest mocks base method.
-func (m *MockEventBridgeAPI) PutPermissionRequest(arg0 *eventbridge.PutPermissionInput) (*request.Request, *eventbridge.PutPermissionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutPermissionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.PutPermissionOutput)
-	return ret0, ret1
-}
-
-// PutPermissionRequest indicates an expected call of PutPermissionRequest.
-func (mr *MockEventBridgeAPIMockRecorder) PutPermissionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPermissionRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutPermissionRequest), arg0)
-}
-
-// PutPermissionWithContext mocks base method.
-func (m *MockEventBridgeAPI) PutPermissionWithContext(arg0 context.Context, arg1 *eventbridge.PutPermissionInput, arg2 ...request.Option) (*eventbridge.PutPermissionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutPermissionWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.PutPermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutPermissionWithContext indicates an expected call of PutPermissionWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) PutPermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPermissionWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutPermissionWithContext), varargs...)
-}
-
-// PutRule mocks base method.
-func (m *MockEventBridgeAPI) PutRule(arg0 *eventbridge.PutRuleInput) (*eventbridge.PutRuleOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutRule", arg0)
-	ret0, _ := ret[0].(*eventbridge.PutRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutRule indicates an expected call of PutRule.
-func (mr *MockEventBridgeAPIMockRecorder) PutRule(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutRule), arg0)
-}
-
-// PutRuleRequest mocks base method.
-func (m *MockEventBridgeAPI) PutRuleRequest(arg0 *eventbridge.PutRuleInput) (*request.Request, *eventbridge.PutRuleOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutRuleRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.PutRuleOutput)
-	return ret0, ret1
-}
-
-// PutRuleRequest indicates an expected call of PutRuleRequest.
-func (mr *MockEventBridgeAPIMockRecorder) PutRuleRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRuleRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutRuleRequest), arg0)
-}
-
-// PutRuleWithContext mocks base method.
-func (m *MockEventBridgeAPI) PutRuleWithContext(arg0 context.Context, arg1 *eventbridge.PutRuleInput, arg2 ...request.Option) (*eventbridge.PutRuleOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutRuleWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.PutRuleOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutRuleWithContext indicates an expected call of PutRuleWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) PutRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRuleWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutRuleWithContext), varargs...)
-}
-
-// PutTargets mocks base method.
-func (m *MockEventBridgeAPI) PutTargets(arg0 *eventbridge.PutTargetsInput) (*eventbridge.PutTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutTargets", arg0)
-	ret0, _ := ret[0].(*eventbridge.PutTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutTargets indicates an expected call of PutTargets.
-func (mr *MockEventBridgeAPIMockRecorder) PutTargets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTargets", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutTargets), arg0)
-}
-
-// PutTargetsRequest mocks base method.
-func (m *MockEventBridgeAPI) PutTargetsRequest(arg0 *eventbridge.PutTargetsInput) (*request.Request, *eventbridge.PutTargetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PutTargetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.PutTargetsOutput)
-	return ret0, ret1
-}
-
-// PutTargetsRequest indicates an expected call of PutTargetsRequest.
-func (mr *MockEventBridgeAPIMockRecorder) PutTargetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTargetsRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutTargetsRequest), arg0)
-}
-
-// PutTargetsWithContext mocks base method.
-func (m *MockEventBridgeAPI) PutTargetsWithContext(arg0 context.Context, arg1 *eventbridge.PutTargetsInput, arg2 ...request.Option) (*eventbridge.PutTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PutTargetsWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.PutTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PutTargetsWithContext indicates an expected call of PutTargetsWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) PutTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTargetsWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutTargetsWithContext), varargs...)
-}
-
-// RemovePermission mocks base method.
-func (m *MockEventBridgeAPI) RemovePermission(arg0 *eventbridge.RemovePermissionInput) (*eventbridge.RemovePermissionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemovePermission", arg0)
-	ret0, _ := ret[0].(*eventbridge.RemovePermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemovePermission indicates an expected call of RemovePermission.
-func (mr *MockEventBridgeAPIMockRecorder) RemovePermission(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermission", reflect.TypeOf((*MockEventBridgeAPI)(nil).RemovePermission), arg0)
-}
-
-// RemovePermissionRequest mocks base method.
-func (m *MockEventBridgeAPI) RemovePermissionRequest(arg0 *eventbridge.RemovePermissionInput) (*request.Request, *eventbridge.RemovePermissionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.RemovePermissionOutput)
-	return ret0, ret1
-}
-
-// RemovePermissionRequest indicates an expected call of RemovePermissionRequest.
-func (mr *MockEventBridgeAPIMockRecorder) RemovePermissionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).RemovePermissionRequest), arg0)
-}
-
-// RemovePermissionWithContext mocks base method.
-func (m *MockEventBridgeAPI) RemovePermissionWithContext(arg0 context.Context, arg1 *eventbridge.RemovePermissionInput, arg2 ...request.Option) (*eventbridge.RemovePermissionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RemovePermissionWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.RemovePermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemovePermissionWithContext indicates an expected call of RemovePermissionWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) RemovePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).RemovePermissionWithContext), varargs...)
-}
-
-// RemoveTargets mocks base method.
-func (m *MockEventBridgeAPI) RemoveTargets(arg0 *eventbridge.RemoveTargetsInput) (*eventbridge.RemoveTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveTargets", arg0)
-	ret0, _ := ret[0].(*eventbridge.RemoveTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveTargets indicates an expected call of RemoveTargets.
-func (mr *MockEventBridgeAPIMockRecorder) RemoveTargets(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTargets", reflect.TypeOf((*MockEventBridgeAPI)(nil).RemoveTargets), arg0)
-}
-
-// RemoveTargetsRequest mocks base method.
-func (m *MockEventBridgeAPI) RemoveTargetsRequest(arg0 *eventbridge.RemoveTargetsInput) (*request.Request, *eventbridge.RemoveTargetsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemoveTargetsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.RemoveTargetsOutput)
-	return ret0, ret1
-}
-
-// RemoveTargetsRequest indicates an expected call of RemoveTargetsRequest.
-func (mr *MockEventBridgeAPIMockRecorder) RemoveTargetsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTargetsRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).RemoveTargetsRequest), arg0)
-}
-
-// RemoveTargetsWithContext mocks base method.
-func (m *MockEventBridgeAPI) RemoveTargetsWithContext(arg0 context.Context, arg1 *eventbridge.RemoveTargetsInput, arg2 ...request.Option) (*eventbridge.RemoveTargetsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RemoveTargetsWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.RemoveTargetsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemoveTargetsWithContext indicates an expected call of RemoveTargetsWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) RemoveTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTargetsWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).RemoveTargetsWithContext), varargs...)
-}
-
-// StartReplay mocks base method.
-func (m *MockEventBridgeAPI) StartReplay(arg0 *eventbridge.StartReplayInput) (*eventbridge.StartReplayOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartReplay", arg0)
-	ret0, _ := ret[0].(*eventbridge.StartReplayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartReplay indicates an expected call of StartReplay.
-func (mr *MockEventBridgeAPIMockRecorder) StartReplay(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartReplay", reflect.TypeOf((*MockEventBridgeAPI)(nil).StartReplay), arg0)
-}
-
-// StartReplayRequest mocks base method.
-func (m *MockEventBridgeAPI) StartReplayRequest(arg0 *eventbridge.StartReplayInput) (*request.Request, *eventbridge.StartReplayOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartReplayRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.StartReplayOutput)
-	return ret0, ret1
-}
-
-// StartReplayRequest indicates an expected call of StartReplayRequest.
-func (mr *MockEventBridgeAPIMockRecorder) StartReplayRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartReplayRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).StartReplayRequest), arg0)
-}
-
-// StartReplayWithContext mocks base method.
-func (m *MockEventBridgeAPI) StartReplayWithContext(arg0 context.Context, arg1 *eventbridge.StartReplayInput, arg2 ...request.Option) (*eventbridge.StartReplayOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StartReplayWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.StartReplayOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartReplayWithContext indicates an expected call of StartReplayWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) StartReplayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartReplayWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).StartReplayWithContext), varargs...)
-}
-
-// TagResource mocks base method.
-func (m *MockEventBridgeAPI) TagResource(arg0 *eventbridge.TagResourceInput) (*eventbridge.TagResourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TagResource", arg0)
-	ret0, _ := ret[0].(*eventbridge.TagResourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TagResource indicates an expected call of TagResource.
-func (mr *MockEventBridgeAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockEventBridgeAPI)(nil).TagResource), arg0)
-}
-
-// TagResourceRequest mocks base method.
-func (m *MockEventBridgeAPI) TagResourceRequest(arg0 *eventbridge.TagResourceInput) (*request.Request, *eventbridge.TagResourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.TagResourceOutput)
-	return ret0, ret1
-}
-
-// TagResourceRequest indicates an expected call of TagResourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).TagResourceRequest), arg0)
-}
-
-// TagResourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) TagResourceWithContext(arg0 context.Context, arg1 *eventbridge.TagResourceInput, arg2 ...request.Option) (*eventbridge.TagResourceOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.TagResourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TagResourceWithContext indicates an expected call of TagResourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).TagResourceWithContext), varargs...)
-}
-
-// TestEventPattern mocks base method.
-func (m *MockEventBridgeAPI) TestEventPattern(arg0 *eventbridge.TestEventPatternInput) (*eventbridge.TestEventPatternOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TestEventPattern", arg0)
-	ret0, _ := ret[0].(*eventbridge.TestEventPatternOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TestEventPattern indicates an expected call of TestEventPattern.
-func (mr *MockEventBridgeAPIMockRecorder) TestEventPattern(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestEventPattern", reflect.TypeOf((*MockEventBridgeAPI)(nil).TestEventPattern), arg0)
-}
-
-// TestEventPatternRequest mocks base method.
-func (m *MockEventBridgeAPI) TestEventPatternRequest(arg0 *eventbridge.TestEventPatternInput) (*request.Request, *eventbridge.TestEventPatternOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TestEventPatternRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.TestEventPatternOutput)
-	return ret0, ret1
-}
-
-// TestEventPatternRequest indicates an expected call of TestEventPatternRequest.
-func (mr *MockEventBridgeAPIMockRecorder) TestEventPatternRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestEventPatternRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).TestEventPatternRequest), arg0)
-}
-
-// TestEventPatternWithContext mocks base method.
-func (m *MockEventBridgeAPI) TestEventPatternWithContext(arg0 context.Context, arg1 *eventbridge.TestEventPatternInput, arg2 ...request.Option) (*eventbridge.TestEventPatternOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "TestEventPatternWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.TestEventPatternOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TestEventPatternWithContext indicates an expected call of TestEventPatternWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) TestEventPatternWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestEventPatternWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).TestEventPatternWithContext), varargs...)
-}
-
-// UntagResource mocks base method.
-func (m *MockEventBridgeAPI) UntagResource(arg0 *eventbridge.UntagResourceInput) (*eventbridge.UntagResourceOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UntagResource", arg0)
-	ret0, _ := ret[0].(*eventbridge.UntagResourceOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UntagResource indicates an expected call of UntagResource.
-func (mr *MockEventBridgeAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockEventBridgeAPI)(nil).UntagResource), arg0)
-}
-
-// UntagResourceRequest mocks base method.
-func (m *MockEventBridgeAPI) UntagResourceRequest(arg0 *eventbridge.UntagResourceInput) (*request.Request, *eventbridge.UntagResourceOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.UntagResourceOutput)
-	return ret0, ret1
-}
-
-// UntagResourceRequest indicates an expected call of UntagResourceRequest.
-func (mr *MockEventBridgeAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).UntagResourceRequest), arg0)
-}
-
-// UntagResourceWithContext mocks base method.
-func (m *MockEventBridgeAPI) UntagResourceWithContext(arg0 context.Context, arg1 *eventbridge.UntagResourceInput, arg2 ...request.Option) (*eventbridge.UntagResourceOutput, error) {
+// DeleteRule mocks base method.
+func (m *MockEventBridgeAPI) DeleteRule(arg0 context.Context, arg1 *eventbridge.DeleteRuleInput, arg2 ...func(*eventbridge.Options)) (*eventbridge.DeleteRuleOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.UntagResourceOutput)
+	ret := m.ctrl.Call(m, "DeleteRule", varargs...)
+	ret0, _ := ret[0].(*eventbridge.DeleteRuleOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// UntagResourceWithContext indicates an expected call of UntagResourceWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteRule indicates an expected call of DeleteRule.
+func (mr *MockEventBridgeAPIMockRecorder) DeleteRule(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).UntagResourceWithContext), varargs...)
-}
-
-// UpdateApiDestination mocks base method.
-func (m *MockEventBridgeAPI) UpdateApiDestination(arg0 *eventbridge.UpdateApiDestinationInput) (*eventbridge.UpdateApiDestinationOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateApiDestination", arg0)
-	ret0, _ := ret[0].(*eventbridge.UpdateApiDestinationOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateApiDestination indicates an expected call of UpdateApiDestination.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateApiDestination(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApiDestination", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateApiDestination), arg0)
-}
-
-// UpdateApiDestinationRequest mocks base method.
-func (m *MockEventBridgeAPI) UpdateApiDestinationRequest(arg0 *eventbridge.UpdateApiDestinationInput) (*request.Request, *eventbridge.UpdateApiDestinationOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateApiDestinationRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.UpdateApiDestinationOutput)
-	return ret0, ret1
-}
-
-// UpdateApiDestinationRequest indicates an expected call of UpdateApiDestinationRequest.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateApiDestinationRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApiDestinationRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateApiDestinationRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).DeleteRule), varargs...)
 }
 
-// UpdateApiDestinationWithContext mocks base method.
-func (m *MockEventBridgeAPI) UpdateApiDestinationWithContext(arg0 context.Context, arg1 *eventbridge.UpdateApiDestinationInput, arg2 ...request.Option) (*eventbridge.UpdateApiDestinationOutput, error) {
+// DescribeRule mocks base method.
+func (m *MockEventBridgeAPI) DescribeRule(arg0 context.Context, arg1 *eventbridge.DescribeRuleInput, arg2 ...func(*eventbridge.Options)) (*eventbridge.DescribeRuleOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "UpdateApiDestinationWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.UpdateApiDestinationOutput)
+	ret := m.ctrl.Call(m, "DescribeRule", varargs...)
+	ret0, _ := ret[0].(*eventbridge.DescribeRuleOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// UpdateApiDestinationWithContext indicates an expected call of UpdateApiDestinationWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateApiDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DescribeRule indicates an expected call of DescribeRule.
+func (mr *MockEventBridgeAPIMockRecorder) DescribeRule(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApiDestinationWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateApiDestinationWithContext), varargs...)
-}
-
-// UpdateArchive mocks base method.
-func (m *MockEventBridgeAPI) UpdateArchive(arg0 *eventbridge.UpdateArchiveInput) (*eventbridge.UpdateArchiveOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateArchive", arg0)
-	ret0, _ := ret[0].(*eventbridge.UpdateArchiveOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateArchive indicates an expected call of UpdateArchive.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateArchive(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArchive", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateArchive), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).DescribeRule), varargs...)
 }
 
-// UpdateArchiveRequest mocks base method.
-func (m *MockEventBridgeAPI) UpdateArchiveRequest(arg0 *eventbridge.UpdateArchiveInput) (*request.Request, *eventbridge.UpdateArchiveOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateArchiveRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.UpdateArchiveOutput)
-	return ret0, ret1
-}
-
-// UpdateArchiveRequest indicates an expected call of UpdateArchiveRequest.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateArchiveRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArchiveRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateArchiveRequest), arg0)
-}
-
-// UpdateArchiveWithContext mocks base method.
-func (m *MockEventBridgeAPI) UpdateArchiveWithContext(arg0 context.Context, arg1 *eventbridge.UpdateArchiveInput, arg2 ...request.Option) (*eventbridge.UpdateArchiveOutput, error) {
+// ListTargetsByRule mocks base method.
+func (m *MockEventBridgeAPI) ListTargetsByRule(arg0 context.Context, arg1 *eventbridge.ListTargetsByRuleInput, arg2 ...func(*eventbridge.Options)) (*eventbridge.ListTargetsByRuleOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "UpdateArchiveWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.UpdateArchiveOutput)
+	ret := m.ctrl.Call(m, "ListTargetsByRule", varargs...)
+	ret0, _ := ret[0].(*eventbridge.ListTargetsByRuleOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// UpdateArchiveWithContext indicates an expected call of UpdateArchiveWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateArchiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ListTargetsByRule indicates an expected call of ListTargetsByRule.
+func (mr *MockEventBridgeAPIMockRecorder) ListTargetsByRule(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArchiveWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateArchiveWithContext), varargs...)
-}
-
-// UpdateConnection mocks base method.
-func (m *MockEventBridgeAPI) UpdateConnection(arg0 *eventbridge.UpdateConnectionInput) (*eventbridge.UpdateConnectionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateConnection", arg0)
-	ret0, _ := ret[0].(*eventbridge.UpdateConnectionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateConnection indicates an expected call of UpdateConnection.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateConnection(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConnection", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateConnection), arg0)
-}
-
-// UpdateConnectionRequest mocks base method.
-func (m *MockEventBridgeAPI) UpdateConnectionRequest(arg0 *eventbridge.UpdateConnectionInput) (*request.Request, *eventbridge.UpdateConnectionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateConnectionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.UpdateConnectionOutput)
-	return ret0, ret1
-}
-
-// UpdateConnectionRequest indicates an expected call of UpdateConnectionRequest.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateConnectionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConnectionRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateConnectionRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTargetsByRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).ListTargetsByRule), varargs...)
 }
 
-// UpdateConnectionWithContext mocks base method.
-func (m *MockEventBridgeAPI) UpdateConnectionWithContext(arg0 context.Context, arg1 *eventbridge.UpdateConnectionInput, arg2 ...request.Option) (*eventbridge.UpdateConnectionOutput, error) {
+// PutRule mocks base method.
+func (m *MockEventBridgeAPI) PutRule(arg0 context.Context, arg1 *eventbridge.PutRuleInput, arg2 ...func(*eventbridge.Options)) (*eventbridge.PutRuleOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "UpdateConnectionWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.UpdateConnectionOutput)
+	ret := m.ctrl.Call(m, "PutRule", varargs...)
+	ret0, _ := ret[0].(*eventbridge.PutRuleOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// UpdateConnectionWithContext indicates an expected call of UpdateConnectionWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// PutRule indicates an expected call of PutRule.
+func (mr *MockEventBridgeAPIMockRecorder) PutRule(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConnectionWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateConnectionWithContext), varargs...)
-}
-
-// UpdateEndpoint mocks base method.
-func (m *MockEventBridgeAPI) UpdateEndpoint(arg0 *eventbridge.UpdateEndpointInput) (*eventbridge.UpdateEndpointOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateEndpoint", arg0)
-	ret0, _ := ret[0].(*eventbridge.UpdateEndpointOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateEndpoint indicates an expected call of UpdateEndpoint.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateEndpoint(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEndpoint", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateEndpoint), arg0)
-}
-
-// UpdateEndpointRequest mocks base method.
-func (m *MockEventBridgeAPI) UpdateEndpointRequest(arg0 *eventbridge.UpdateEndpointInput) (*request.Request, *eventbridge.UpdateEndpointOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateEndpointRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.UpdateEndpointOutput)
-	return ret0, ret1
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRule", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutRule), varargs...)
 }
 
-// UpdateEndpointRequest indicates an expected call of UpdateEndpointRequest.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateEndpointRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEndpointRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateEndpointRequest), arg0)
-}
-
-// UpdateEndpointWithContext mocks base method.
-func (m *MockEventBridgeAPI) UpdateEndpointWithContext(arg0 context.Context, arg1 *eventbridge.UpdateEndpointInput, arg2 ...request.Option) (*eventbridge.UpdateEndpointOutput, error) {
+// PutTargets mocks base method.
+func (m *MockEventBridgeAPI) PutTargets(arg0 context.Context, arg1 *eventbridge.PutTargetsInput, arg2 ...func(*eventbridge.Options)) (*eventbridge.PutTargetsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "UpdateEndpointWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.UpdateEndpointOutput)
+	ret := m.ctrl.Call(m, "PutTargets", varargs...)
+	ret0, _ := ret[0].(*eventbridge.PutTargetsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// UpdateEndpointWithContext indicates an expected call of UpdateEndpointWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// PutTargets indicates an expected call of PutTargets.
+func (mr *MockEventBridgeAPIMockRecorder) PutTargets(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEndpointWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateEndpointWithContext), varargs...)
-}
-
-// UpdateEventBus mocks base method.
-func (m *MockEventBridgeAPI) UpdateEventBus(arg0 *eventbridge.UpdateEventBusInput) (*eventbridge.UpdateEventBusOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateEventBus", arg0)
-	ret0, _ := ret[0].(*eventbridge.UpdateEventBusOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateEventBus indicates an expected call of UpdateEventBus.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateEventBus(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEventBus", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateEventBus), arg0)
-}
-
-// UpdateEventBusRequest mocks base method.
-func (m *MockEventBridgeAPI) UpdateEventBusRequest(arg0 *eventbridge.UpdateEventBusInput) (*request.Request, *eventbridge.UpdateEventBusOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateEventBusRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*eventbridge.UpdateEventBusOutput)
-	return ret0, ret1
-}
-
-// UpdateEventBusRequest indicates an expected call of UpdateEventBusRequest.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateEventBusRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEventBusRequest", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateEventBusRequest), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTargets", reflect.TypeOf((*MockEventBridgeAPI)(nil).PutTargets), varargs...)
 }
 
-// UpdateEventBusWithContext mocks base method.
-func (m *MockEventBridgeAPI) UpdateEventBusWithContext(arg0 context.Context, arg1 *eventbridge.UpdateEventBusInput, arg2 ...request.Option) (*eventbridge.UpdateEventBusOutput, error) {
+// RemoveTargets mocks base method.
+func (m *MockEventBridgeAPI) RemoveTargets(arg0 context.Context, arg1 *eventbridge.RemoveTargetsInput, arg2 ...func(*eventbridge.Options)) (*eventbridge.RemoveTargetsOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "UpdateEventBusWithContext", varargs...)
-	ret0, _ := ret[0].(*eventbridge.UpdateEventBusOutput)
+	ret := m.ctrl.Call(m, "RemoveTargets", varargs...)
+	ret0, _ := ret[0].(*eventbridge.RemoveTargetsOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// UpdateEventBusWithContext indicates an expected call of UpdateEventBusWithContext.
-func (mr *MockEventBridgeAPIMockRecorder) UpdateEventBusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// RemoveTargets indicates an expected call of RemoveTargets.
+func (mr *MockEventBridgeAPIMockRecorder) RemoveTargets(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEventBusWithContext", reflect.TypeOf((*MockEventBridgeAPI)(nil).UpdateEventBusWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTargets", reflect.TypeOf((*MockEventBridgeAPI)(nil).RemoveTargets), varargs...)
 }
diff --git a/pkg/cloud/services/instancestate/mock_sqsiface/doc.go b/pkg/cloud/services/instancestate/mock_sqsiface/doc.go
index 57fb6a934..8ccdfc456 100644
--- a/pkg/cloud/services/instancestate/mock_sqsiface/doc.go
+++ b/pkg/cloud/services/instancestate/mock_sqsiface/doc.go
@@ -17,6 +17,6 @@ limitations under the License.
 // Package mock_sqsiface provides a mock implementation for the SQSAPI interface.
 // Run go generate to regenerate this mock.
 //
-//go:generate ../../../../../hack/tools/bin/mockgen -destination sqsiface_mock.go -package mock_sqsiface github.com/aws/aws-sdk-go/service/sqs/sqsiface SQSAPI
+//go:generate ../../../../../hack/tools/bin/mockgen -destination sqsiface_mock.go -package mock_sqsiface sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/instancestate SQSAPI
 //go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt sqsiface_mock.go > _sqsiface_mock.go && mv _sqsiface_mock.go sqsiface_mock.go"
 package mock_sqsiface //nolint:stylecheck
diff --git a/pkg/cloud/services/instancestate/mock_sqsiface/sqsiface_mock.go b/pkg/cloud/services/instancestate/mock_sqsiface/sqsiface_mock.go
index 23933bd62..d6979ba67 100644
--- a/pkg/cloud/services/instancestate/mock_sqsiface/sqsiface_mock.go
+++ b/pkg/cloud/services/instancestate/mock_sqsiface/sqsiface_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/sqs/sqsiface (interfaces: SQSAPI)
+// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/instancestate (interfaces: SQSAPI)
 
 // Package mock_sqsiface is a generated GoMock package.
 package mock_sqsiface
@@ -24,8 +24,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	request "github.com/aws/aws-sdk-go/aws/request"
-	sqs "github.com/aws/aws-sdk-go/service/sqs"
+	sqs "github.com/aws/aws-sdk-go-v2/service/sqs"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -52,1218 +51,142 @@ func (m *MockSQSAPI) EXPECT() *MockSQSAPIMockRecorder {
 	return m.recorder
 }
 
-// AddPermission mocks base method.
-func (m *MockSQSAPI) AddPermission(arg0 *sqs.AddPermissionInput) (*sqs.AddPermissionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddPermission", arg0)
-	ret0, _ := ret[0].(*sqs.AddPermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AddPermission indicates an expected call of AddPermission.
-func (mr *MockSQSAPIMockRecorder) AddPermission(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermission", reflect.TypeOf((*MockSQSAPI)(nil).AddPermission), arg0)
-}
-
-// AddPermissionRequest mocks base method.
-func (m *MockSQSAPI) AddPermissionRequest(arg0 *sqs.AddPermissionInput) (*request.Request, *sqs.AddPermissionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddPermissionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.AddPermissionOutput)
-	return ret0, ret1
-}
-
-// AddPermissionRequest indicates an expected call of AddPermissionRequest.
-func (mr *MockSQSAPIMockRecorder) AddPermissionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionRequest", reflect.TypeOf((*MockSQSAPI)(nil).AddPermissionRequest), arg0)
-}
-
-// AddPermissionWithContext mocks base method.
-func (m *MockSQSAPI) AddPermissionWithContext(arg0 context.Context, arg1 *sqs.AddPermissionInput, arg2 ...request.Option) (*sqs.AddPermissionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "AddPermissionWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.AddPermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// AddPermissionWithContext indicates an expected call of AddPermissionWithContext.
-func (mr *MockSQSAPIMockRecorder) AddPermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionWithContext", reflect.TypeOf((*MockSQSAPI)(nil).AddPermissionWithContext), varargs...)
-}
-
-// CancelMessageMoveTask mocks base method.
-func (m *MockSQSAPI) CancelMessageMoveTask(arg0 *sqs.CancelMessageMoveTaskInput) (*sqs.CancelMessageMoveTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelMessageMoveTask", arg0)
-	ret0, _ := ret[0].(*sqs.CancelMessageMoveTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelMessageMoveTask indicates an expected call of CancelMessageMoveTask.
-func (mr *MockSQSAPIMockRecorder) CancelMessageMoveTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelMessageMoveTask", reflect.TypeOf((*MockSQSAPI)(nil).CancelMessageMoveTask), arg0)
-}
-
-// CancelMessageMoveTaskRequest mocks base method.
-func (m *MockSQSAPI) CancelMessageMoveTaskRequest(arg0 *sqs.CancelMessageMoveTaskInput) (*request.Request, *sqs.CancelMessageMoveTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CancelMessageMoveTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.CancelMessageMoveTaskOutput)
-	return ret0, ret1
-}
-
-// CancelMessageMoveTaskRequest indicates an expected call of CancelMessageMoveTaskRequest.
-func (mr *MockSQSAPIMockRecorder) CancelMessageMoveTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelMessageMoveTaskRequest", reflect.TypeOf((*MockSQSAPI)(nil).CancelMessageMoveTaskRequest), arg0)
-}
-
-// CancelMessageMoveTaskWithContext mocks base method.
-func (m *MockSQSAPI) CancelMessageMoveTaskWithContext(arg0 context.Context, arg1 *sqs.CancelMessageMoveTaskInput, arg2 ...request.Option) (*sqs.CancelMessageMoveTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "CancelMessageMoveTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.CancelMessageMoveTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CancelMessageMoveTaskWithContext indicates an expected call of CancelMessageMoveTaskWithContext.
-func (mr *MockSQSAPIMockRecorder) CancelMessageMoveTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelMessageMoveTaskWithContext", reflect.TypeOf((*MockSQSAPI)(nil).CancelMessageMoveTaskWithContext), varargs...)
-}
-
-// ChangeMessageVisibility mocks base method.
-func (m *MockSQSAPI) ChangeMessageVisibility(arg0 *sqs.ChangeMessageVisibilityInput) (*sqs.ChangeMessageVisibilityOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ChangeMessageVisibility", arg0)
-	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ChangeMessageVisibility indicates an expected call of ChangeMessageVisibility.
-func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibility(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibility", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibility), arg0)
-}
-
-// ChangeMessageVisibilityBatch mocks base method.
-func (m *MockSQSAPI) ChangeMessageVisibilityBatch(arg0 *sqs.ChangeMessageVisibilityBatchInput) (*sqs.ChangeMessageVisibilityBatchOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatch", arg0)
-	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityBatchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ChangeMessageVisibilityBatch indicates an expected call of ChangeMessageVisibilityBatch.
-func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityBatch(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatch", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityBatch), arg0)
-}
-
-// ChangeMessageVisibilityBatchRequest mocks base method.
-func (m *MockSQSAPI) ChangeMessageVisibilityBatchRequest(arg0 *sqs.ChangeMessageVisibilityBatchInput) (*request.Request, *sqs.ChangeMessageVisibilityBatchOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatchRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.ChangeMessageVisibilityBatchOutput)
-	return ret0, ret1
-}
-
-// ChangeMessageVisibilityBatchRequest indicates an expected call of ChangeMessageVisibilityBatchRequest.
-func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityBatchRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityBatchRequest), arg0)
-}
-
-// ChangeMessageVisibilityBatchWithContext mocks base method.
-func (m *MockSQSAPI) ChangeMessageVisibilityBatchWithContext(arg0 context.Context, arg1 *sqs.ChangeMessageVisibilityBatchInput, arg2 ...request.Option) (*sqs.ChangeMessageVisibilityBatchOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatchWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityBatchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ChangeMessageVisibilityBatchWithContext indicates an expected call of ChangeMessageVisibilityBatchWithContext.
-func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatchWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityBatchWithContext), varargs...)
-}
-
-// ChangeMessageVisibilityRequest mocks base method.
-func (m *MockSQSAPI) ChangeMessageVisibilityRequest(arg0 *sqs.ChangeMessageVisibilityInput) (*request.Request, *sqs.ChangeMessageVisibilityOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ChangeMessageVisibilityRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.ChangeMessageVisibilityOutput)
-	return ret0, ret1
-}
-
-// ChangeMessageVisibilityRequest indicates an expected call of ChangeMessageVisibilityRequest.
-func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityRequest", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityRequest), arg0)
-}
-
-// ChangeMessageVisibilityWithContext mocks base method.
-func (m *MockSQSAPI) ChangeMessageVisibilityWithContext(arg0 context.Context, arg1 *sqs.ChangeMessageVisibilityInput, arg2 ...request.Option) (*sqs.ChangeMessageVisibilityOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ChangeMessageVisibilityWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ChangeMessageVisibilityWithContext indicates an expected call of ChangeMessageVisibilityWithContext.
-func (mr *MockSQSAPIMockRecorder) ChangeMessageVisibilityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityWithContext), varargs...)
-}
-
 // CreateQueue mocks base method.
-func (m *MockSQSAPI) CreateQueue(arg0 *sqs.CreateQueueInput) (*sqs.CreateQueueOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateQueue", arg0)
-	ret0, _ := ret[0].(*sqs.CreateQueueOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateQueue indicates an expected call of CreateQueue.
-func (mr *MockSQSAPIMockRecorder) CreateQueue(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueue", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueue), arg0)
-}
-
-// CreateQueueRequest mocks base method.
-func (m *MockSQSAPI) CreateQueueRequest(arg0 *sqs.CreateQueueInput) (*request.Request, *sqs.CreateQueueOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateQueueRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.CreateQueueOutput)
-	return ret0, ret1
-}
-
-// CreateQueueRequest indicates an expected call of CreateQueueRequest.
-func (mr *MockSQSAPIMockRecorder) CreateQueueRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueueRequest), arg0)
-}
-
-// CreateQueueWithContext mocks base method.
-func (m *MockSQSAPI) CreateQueueWithContext(arg0 context.Context, arg1 *sqs.CreateQueueInput, arg2 ...request.Option) (*sqs.CreateQueueOutput, error) {
+func (m *MockSQSAPI) CreateQueue(arg0 context.Context, arg1 *sqs.CreateQueueInput, arg2 ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "CreateQueueWithContext", varargs...)
+	ret := m.ctrl.Call(m, "CreateQueue", varargs...)
 	ret0, _ := ret[0].(*sqs.CreateQueueOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// CreateQueueWithContext indicates an expected call of CreateQueueWithContext.
-func (mr *MockSQSAPIMockRecorder) CreateQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateQueue indicates an expected call of CreateQueue.
+func (mr *MockSQSAPIMockRecorder) CreateQueue(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueueWithContext", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueueWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueue", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueue), varargs...)
 }
 
 // DeleteMessage mocks base method.
-func (m *MockSQSAPI) DeleteMessage(arg0 *sqs.DeleteMessageInput) (*sqs.DeleteMessageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteMessage", arg0)
-	ret0, _ := ret[0].(*sqs.DeleteMessageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteMessage indicates an expected call of DeleteMessage.
-func (mr *MockSQSAPIMockRecorder) DeleteMessage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessage), arg0)
-}
-
-// DeleteMessageBatch mocks base method.
-func (m *MockSQSAPI) DeleteMessageBatch(arg0 *sqs.DeleteMessageBatchInput) (*sqs.DeleteMessageBatchOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteMessageBatch", arg0)
-	ret0, _ := ret[0].(*sqs.DeleteMessageBatchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteMessageBatch indicates an expected call of DeleteMessageBatch.
-func (mr *MockSQSAPIMockRecorder) DeleteMessageBatch(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatch", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageBatch), arg0)
-}
-
-// DeleteMessageBatchRequest mocks base method.
-func (m *MockSQSAPI) DeleteMessageBatchRequest(arg0 *sqs.DeleteMessageBatchInput) (*request.Request, *sqs.DeleteMessageBatchOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteMessageBatchRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.DeleteMessageBatchOutput)
-	return ret0, ret1
-}
-
-// DeleteMessageBatchRequest indicates an expected call of DeleteMessageBatchRequest.
-func (mr *MockSQSAPIMockRecorder) DeleteMessageBatchRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageBatchRequest), arg0)
-}
-
-// DeleteMessageBatchWithContext mocks base method.
-func (m *MockSQSAPI) DeleteMessageBatchWithContext(arg0 context.Context, arg1 *sqs.DeleteMessageBatchInput, arg2 ...request.Option) (*sqs.DeleteMessageBatchOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "DeleteMessageBatchWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.DeleteMessageBatchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteMessageBatchWithContext indicates an expected call of DeleteMessageBatchWithContext.
-func (mr *MockSQSAPIMockRecorder) DeleteMessageBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatchWithContext", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageBatchWithContext), varargs...)
-}
-
-// DeleteMessageRequest mocks base method.
-func (m *MockSQSAPI) DeleteMessageRequest(arg0 *sqs.DeleteMessageInput) (*request.Request, *sqs.DeleteMessageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteMessageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.DeleteMessageOutput)
-	return ret0, ret1
-}
-
-// DeleteMessageRequest indicates an expected call of DeleteMessageRequest.
-func (mr *MockSQSAPIMockRecorder) DeleteMessageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageRequest), arg0)
-}
-
-// DeleteMessageWithContext mocks base method.
-func (m *MockSQSAPI) DeleteMessageWithContext(arg0 context.Context, arg1 *sqs.DeleteMessageInput, arg2 ...request.Option) (*sqs.DeleteMessageOutput, error) {
+func (m *MockSQSAPI) DeleteMessage(arg0 context.Context, arg1 *sqs.DeleteMessageInput, arg2 ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteMessageWithContext", varargs...)
+	ret := m.ctrl.Call(m, "DeleteMessage", varargs...)
 	ret0, _ := ret[0].(*sqs.DeleteMessageOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteMessageWithContext indicates an expected call of DeleteMessageWithContext.
-func (mr *MockSQSAPIMockRecorder) DeleteMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteMessage indicates an expected call of DeleteMessage.
+func (mr *MockSQSAPIMockRecorder) DeleteMessage(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageWithContext", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessage), varargs...)
 }
 
 // DeleteQueue mocks base method.
-func (m *MockSQSAPI) DeleteQueue(arg0 *sqs.DeleteQueueInput) (*sqs.DeleteQueueOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteQueue", arg0)
-	ret0, _ := ret[0].(*sqs.DeleteQueueOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// DeleteQueue indicates an expected call of DeleteQueue.
-func (mr *MockSQSAPIMockRecorder) DeleteQueue(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueue", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueue), arg0)
-}
-
-// DeleteQueueRequest mocks base method.
-func (m *MockSQSAPI) DeleteQueueRequest(arg0 *sqs.DeleteQueueInput) (*request.Request, *sqs.DeleteQueueOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteQueueRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.DeleteQueueOutput)
-	return ret0, ret1
-}
-
-// DeleteQueueRequest indicates an expected call of DeleteQueueRequest.
-func (mr *MockSQSAPIMockRecorder) DeleteQueueRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueueRequest), arg0)
-}
-
-// DeleteQueueWithContext mocks base method.
-func (m *MockSQSAPI) DeleteQueueWithContext(arg0 context.Context, arg1 *sqs.DeleteQueueInput, arg2 ...request.Option) (*sqs.DeleteQueueOutput, error) {
+func (m *MockSQSAPI) DeleteQueue(arg0 context.Context, arg1 *sqs.DeleteQueueInput, arg2 ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "DeleteQueueWithContext", varargs...)
+	ret := m.ctrl.Call(m, "DeleteQueue", varargs...)
 	ret0, _ := ret[0].(*sqs.DeleteQueueOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// DeleteQueueWithContext indicates an expected call of DeleteQueueWithContext.
-func (mr *MockSQSAPIMockRecorder) DeleteQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteQueue indicates an expected call of DeleteQueue.
+func (mr *MockSQSAPIMockRecorder) DeleteQueue(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueueWithContext", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueueWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueue", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueue), varargs...)
 }
 
 // GetQueueAttributes mocks base method.
-func (m *MockSQSAPI) GetQueueAttributes(arg0 *sqs.GetQueueAttributesInput) (*sqs.GetQueueAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetQueueAttributes", arg0)
-	ret0, _ := ret[0].(*sqs.GetQueueAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetQueueAttributes indicates an expected call of GetQueueAttributes.
-func (mr *MockSQSAPIMockRecorder) GetQueueAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributes", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributes), arg0)
-}
-
-// GetQueueAttributesRequest mocks base method.
-func (m *MockSQSAPI) GetQueueAttributesRequest(arg0 *sqs.GetQueueAttributesInput) (*request.Request, *sqs.GetQueueAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetQueueAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.GetQueueAttributesOutput)
-	return ret0, ret1
-}
-
-// GetQueueAttributesRequest indicates an expected call of GetQueueAttributesRequest.
-func (mr *MockSQSAPIMockRecorder) GetQueueAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributesRequest", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributesRequest), arg0)
-}
-
-// GetQueueAttributesWithContext mocks base method.
-func (m *MockSQSAPI) GetQueueAttributesWithContext(arg0 context.Context, arg1 *sqs.GetQueueAttributesInput, arg2 ...request.Option) (*sqs.GetQueueAttributesOutput, error) {
+func (m *MockSQSAPI) GetQueueAttributes(arg0 context.Context, arg1 *sqs.GetQueueAttributesInput, arg2 ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "GetQueueAttributesWithContext", varargs...)
+	ret := m.ctrl.Call(m, "GetQueueAttributes", varargs...)
 	ret0, _ := ret[0].(*sqs.GetQueueAttributesOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// GetQueueAttributesWithContext indicates an expected call of GetQueueAttributesWithContext.
-func (mr *MockSQSAPIMockRecorder) GetQueueAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// GetQueueAttributes indicates an expected call of GetQueueAttributes.
+func (mr *MockSQSAPIMockRecorder) GetQueueAttributes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributesWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributes", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributes), varargs...)
 }
 
 // GetQueueUrl mocks base method.
-func (m *MockSQSAPI) GetQueueUrl(arg0 *sqs.GetQueueUrlInput) (*sqs.GetQueueUrlOutput, error) {
+func (m *MockSQSAPI) GetQueueUrl(arg0 context.Context, arg1 *sqs.GetQueueUrlInput, arg2 ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetQueueUrl", arg0)
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetQueueUrl", varargs...)
 	ret0, _ := ret[0].(*sqs.GetQueueUrlOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // GetQueueUrl indicates an expected call of GetQueueUrl.
-func (mr *MockSQSAPIMockRecorder) GetQueueUrl(arg0 interface{}) *gomock.Call {
+func (mr *MockSQSAPIMockRecorder) GetQueueUrl(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrl", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrl), arg0)
-}
-
-// GetQueueUrlRequest mocks base method.
-func (m *MockSQSAPI) GetQueueUrlRequest(arg0 *sqs.GetQueueUrlInput) (*request.Request, *sqs.GetQueueUrlOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetQueueUrlRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.GetQueueUrlOutput)
-	return ret0, ret1
-}
-
-// GetQueueUrlRequest indicates an expected call of GetQueueUrlRequest.
-func (mr *MockSQSAPIMockRecorder) GetQueueUrlRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrlRequest", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrlRequest), arg0)
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrl", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrl), varargs...)
 }
 
-// GetQueueUrlWithContext mocks base method.
-func (m *MockSQSAPI) GetQueueUrlWithContext(arg0 context.Context, arg1 *sqs.GetQueueUrlInput, arg2 ...request.Option) (*sqs.GetQueueUrlOutput, error) {
+// ReceiveMessage mocks base method.
+func (m *MockSQSAPI) ReceiveMessage(arg0 context.Context, arg1 *sqs.ReceiveMessageInput, arg2 ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "GetQueueUrlWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.GetQueueUrlOutput)
+	ret := m.ctrl.Call(m, "ReceiveMessage", varargs...)
+	ret0, _ := ret[0].(*sqs.ReceiveMessageOutput)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// GetQueueUrlWithContext indicates an expected call of GetQueueUrlWithContext.
-func (mr *MockSQSAPIMockRecorder) GetQueueUrlWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ReceiveMessage indicates an expected call of ReceiveMessage.
+func (mr *MockSQSAPIMockRecorder) ReceiveMessage(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrlWithContext", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrlWithContext), varargs...)
-}
-
-// ListDeadLetterSourceQueues mocks base method.
-func (m *MockSQSAPI) ListDeadLetterSourceQueues(arg0 *sqs.ListDeadLetterSourceQueuesInput) (*sqs.ListDeadLetterSourceQueuesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueues", arg0)
-	ret0, _ := ret[0].(*sqs.ListDeadLetterSourceQueuesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListDeadLetterSourceQueues indicates an expected call of ListDeadLetterSourceQueues.
-func (mr *MockSQSAPIMockRecorder) ListDeadLetterSourceQueues(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueues", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueues), arg0)
-}
-
-// ListDeadLetterSourceQueuesPages mocks base method.
-func (m *MockSQSAPI) ListDeadLetterSourceQueuesPages(arg0 *sqs.ListDeadLetterSourceQueuesInput, arg1 func(*sqs.ListDeadLetterSourceQueuesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ListDeadLetterSourceQueuesPages indicates an expected call of ListDeadLetterSourceQueuesPages.
-func (mr *MockSQSAPIMockRecorder) ListDeadLetterSourceQueuesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesPages", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesPages), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessage", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessage), varargs...)
 }
 
-// ListDeadLetterSourceQueuesPagesWithContext mocks base method.
-func (m *MockSQSAPI) ListDeadLetterSourceQueuesPagesWithContext(arg0 context.Context, arg1 *sqs.ListDeadLetterSourceQueuesInput, arg2 func(*sqs.ListDeadLetterSourceQueuesOutput, bool) bool, arg3 ...request.Option) error {
+// SetQueueAttributes mocks base method.
+func (m *MockSQSAPI) SetQueueAttributes(arg0 context.Context, arg1 *sqs.SetQueueAttributesInput, arg2 ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ListDeadLetterSourceQueuesPagesWithContext indicates an expected call of ListDeadLetterSourceQueuesPagesWithContext.
-func (mr *MockSQSAPIMockRecorder) ListDeadLetterSourceQueuesPagesWithContext(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, "ListDeadLetterSourceQueuesPagesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesPagesWithContext), varargs...)
-}
-
-// ListDeadLetterSourceQueuesRequest mocks base method.
-func (m *MockSQSAPI) ListDeadLetterSourceQueuesRequest(arg0 *sqs.ListDeadLetterSourceQueuesInput) (*request.Request, *sqs.ListDeadLetterSourceQueuesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.ListDeadLetterSourceQueuesOutput)
-	return ret0, ret1
-}
-
-// ListDeadLetterSourceQueuesRequest indicates an expected call of ListDeadLetterSourceQueuesRequest.
-func (mr *MockSQSAPIMockRecorder) ListDeadLetterSourceQueuesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesRequest), arg0)
-}
-
-// ListDeadLetterSourceQueuesWithContext mocks base method.
-func (m *MockSQSAPI) ListDeadLetterSourceQueuesWithContext(arg0 context.Context, arg1 *sqs.ListDeadLetterSourceQueuesInput, arg2 ...request.Option) (*sqs.ListDeadLetterSourceQueuesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.ListDeadLetterSourceQueuesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListDeadLetterSourceQueuesWithContext indicates an expected call of ListDeadLetterSourceQueuesWithContext.
-func (mr *MockSQSAPIMockRecorder) ListDeadLetterSourceQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesWithContext), varargs...)
-}
-
-// ListMessageMoveTasks mocks base method.
-func (m *MockSQSAPI) ListMessageMoveTasks(arg0 *sqs.ListMessageMoveTasksInput) (*sqs.ListMessageMoveTasksOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListMessageMoveTasks", arg0)
-	ret0, _ := ret[0].(*sqs.ListMessageMoveTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListMessageMoveTasks indicates an expected call of ListMessageMoveTasks.
-func (mr *MockSQSAPIMockRecorder) ListMessageMoveTasks(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMessageMoveTasks", reflect.TypeOf((*MockSQSAPI)(nil).ListMessageMoveTasks), arg0)
-}
-
-// ListMessageMoveTasksRequest mocks base method.
-func (m *MockSQSAPI) ListMessageMoveTasksRequest(arg0 *sqs.ListMessageMoveTasksInput) (*request.Request, *sqs.ListMessageMoveTasksOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListMessageMoveTasksRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.ListMessageMoveTasksOutput)
-	return ret0, ret1
-}
-
-// ListMessageMoveTasksRequest indicates an expected call of ListMessageMoveTasksRequest.
-func (mr *MockSQSAPIMockRecorder) ListMessageMoveTasksRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMessageMoveTasksRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListMessageMoveTasksRequest), arg0)
-}
-
-// ListMessageMoveTasksWithContext mocks base method.
-func (m *MockSQSAPI) ListMessageMoveTasksWithContext(arg0 context.Context, arg1 *sqs.ListMessageMoveTasksInput, arg2 ...request.Option) (*sqs.ListMessageMoveTasksOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListMessageMoveTasksWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.ListMessageMoveTasksOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListMessageMoveTasksWithContext indicates an expected call of ListMessageMoveTasksWithContext.
-func (mr *MockSQSAPIMockRecorder) ListMessageMoveTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMessageMoveTasksWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ListMessageMoveTasksWithContext), varargs...)
-}
-
-// ListQueueTags mocks base method.
-func (m *MockSQSAPI) ListQueueTags(arg0 *sqs.ListQueueTagsInput) (*sqs.ListQueueTagsOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListQueueTags", arg0)
-	ret0, _ := ret[0].(*sqs.ListQueueTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListQueueTags indicates an expected call of ListQueueTags.
-func (mr *MockSQSAPIMockRecorder) ListQueueTags(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueueTags", reflect.TypeOf((*MockSQSAPI)(nil).ListQueueTags), arg0)
-}
-
-// ListQueueTagsRequest mocks base method.
-func (m *MockSQSAPI) ListQueueTagsRequest(arg0 *sqs.ListQueueTagsInput) (*request.Request, *sqs.ListQueueTagsOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListQueueTagsRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.ListQueueTagsOutput)
-	return ret0, ret1
-}
-
-// ListQueueTagsRequest indicates an expected call of ListQueueTagsRequest.
-func (mr *MockSQSAPIMockRecorder) ListQueueTagsRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueueTagsRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListQueueTagsRequest), arg0)
-}
-
-// ListQueueTagsWithContext mocks base method.
-func (m *MockSQSAPI) ListQueueTagsWithContext(arg0 context.Context, arg1 *sqs.ListQueueTagsInput, arg2 ...request.Option) (*sqs.ListQueueTagsOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListQueueTagsWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.ListQueueTagsOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListQueueTagsWithContext indicates an expected call of ListQueueTagsWithContext.
-func (mr *MockSQSAPIMockRecorder) ListQueueTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueueTagsWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ListQueueTagsWithContext), varargs...)
-}
-
-// ListQueues mocks base method.
-func (m *MockSQSAPI) ListQueues(arg0 *sqs.ListQueuesInput) (*sqs.ListQueuesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListQueues", arg0)
-	ret0, _ := ret[0].(*sqs.ListQueuesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListQueues indicates an expected call of ListQueues.
-func (mr *MockSQSAPIMockRecorder) ListQueues(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueues", reflect.TypeOf((*MockSQSAPI)(nil).ListQueues), arg0)
-}
-
-// ListQueuesPages mocks base method.
-func (m *MockSQSAPI) ListQueuesPages(arg0 *sqs.ListQueuesInput, arg1 func(*sqs.ListQueuesOutput, bool) bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListQueuesPages", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ListQueuesPages indicates an expected call of ListQueuesPages.
-func (mr *MockSQSAPIMockRecorder) ListQueuesPages(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesPages", reflect.TypeOf((*MockSQSAPI)(nil).ListQueuesPages), arg0, arg1)
-}
-
-// ListQueuesPagesWithContext mocks base method.
-func (m *MockSQSAPI) ListQueuesPagesWithContext(arg0 context.Context, arg1 *sqs.ListQueuesInput, arg2 func(*sqs.ListQueuesOutput, 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, "ListQueuesPagesWithContext", varargs...)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ListQueuesPagesWithContext indicates an expected call of ListQueuesPagesWithContext.
-func (mr *MockSQSAPIMockRecorder) ListQueuesPagesWithContext(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, "ListQueuesPagesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ListQueuesPagesWithContext), varargs...)
-}
-
-// ListQueuesRequest mocks base method.
-func (m *MockSQSAPI) ListQueuesRequest(arg0 *sqs.ListQueuesInput) (*request.Request, *sqs.ListQueuesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListQueuesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.ListQueuesOutput)
-	return ret0, ret1
-}
-
-// ListQueuesRequest indicates an expected call of ListQueuesRequest.
-func (mr *MockSQSAPIMockRecorder) ListQueuesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListQueuesRequest), arg0)
-}
-
-// ListQueuesWithContext mocks base method.
-func (m *MockSQSAPI) ListQueuesWithContext(arg0 context.Context, arg1 *sqs.ListQueuesInput, arg2 ...request.Option) (*sqs.ListQueuesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListQueuesWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.ListQueuesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListQueuesWithContext indicates an expected call of ListQueuesWithContext.
-func (mr *MockSQSAPIMockRecorder) ListQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ListQueuesWithContext), varargs...)
-}
-
-// PurgeQueue mocks base method.
-func (m *MockSQSAPI) PurgeQueue(arg0 *sqs.PurgeQueueInput) (*sqs.PurgeQueueOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurgeQueue", arg0)
-	ret0, _ := ret[0].(*sqs.PurgeQueueOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurgeQueue indicates an expected call of PurgeQueue.
-func (mr *MockSQSAPIMockRecorder) PurgeQueue(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueue", reflect.TypeOf((*MockSQSAPI)(nil).PurgeQueue), arg0)
-}
-
-// PurgeQueueRequest mocks base method.
-func (m *MockSQSAPI) PurgeQueueRequest(arg0 *sqs.PurgeQueueInput) (*request.Request, *sqs.PurgeQueueOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PurgeQueueRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.PurgeQueueOutput)
-	return ret0, ret1
-}
-
-// PurgeQueueRequest indicates an expected call of PurgeQueueRequest.
-func (mr *MockSQSAPIMockRecorder) PurgeQueueRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).PurgeQueueRequest), arg0)
-}
-
-// PurgeQueueWithContext mocks base method.
-func (m *MockSQSAPI) PurgeQueueWithContext(arg0 context.Context, arg1 *sqs.PurgeQueueInput, arg2 ...request.Option) (*sqs.PurgeQueueOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PurgeQueueWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.PurgeQueueOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PurgeQueueWithContext indicates an expected call of PurgeQueueWithContext.
-func (mr *MockSQSAPIMockRecorder) PurgeQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueueWithContext", reflect.TypeOf((*MockSQSAPI)(nil).PurgeQueueWithContext), varargs...)
-}
-
-// ReceiveMessage mocks base method.
-func (m *MockSQSAPI) ReceiveMessage(arg0 *sqs.ReceiveMessageInput) (*sqs.ReceiveMessageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReceiveMessage", arg0)
-	ret0, _ := ret[0].(*sqs.ReceiveMessageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReceiveMessage indicates an expected call of ReceiveMessage.
-func (mr *MockSQSAPIMockRecorder) ReceiveMessage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessage", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessage), arg0)
-}
-
-// ReceiveMessageRequest mocks base method.
-func (m *MockSQSAPI) ReceiveMessageRequest(arg0 *sqs.ReceiveMessageInput) (*request.Request, *sqs.ReceiveMessageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReceiveMessageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.ReceiveMessageOutput)
-	return ret0, ret1
-}
-
-// ReceiveMessageRequest indicates an expected call of ReceiveMessageRequest.
-func (mr *MockSQSAPIMockRecorder) ReceiveMessageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessageRequest), arg0)
-}
-
-// ReceiveMessageWithContext mocks base method.
-func (m *MockSQSAPI) ReceiveMessageWithContext(arg0 context.Context, arg1 *sqs.ReceiveMessageInput, arg2 ...request.Option) (*sqs.ReceiveMessageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ReceiveMessageWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.ReceiveMessageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ReceiveMessageWithContext indicates an expected call of ReceiveMessageWithContext.
-func (mr *MockSQSAPIMockRecorder) ReceiveMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessageWithContext", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessageWithContext), varargs...)
-}
-
-// RemovePermission mocks base method.
-func (m *MockSQSAPI) RemovePermission(arg0 *sqs.RemovePermissionInput) (*sqs.RemovePermissionOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemovePermission", arg0)
-	ret0, _ := ret[0].(*sqs.RemovePermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemovePermission indicates an expected call of RemovePermission.
-func (mr *MockSQSAPIMockRecorder) RemovePermission(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermission", reflect.TypeOf((*MockSQSAPI)(nil).RemovePermission), arg0)
-}
-
-// RemovePermissionRequest mocks base method.
-func (m *MockSQSAPI) RemovePermissionRequest(arg0 *sqs.RemovePermissionInput) (*request.Request, *sqs.RemovePermissionOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.RemovePermissionOutput)
-	return ret0, ret1
-}
-
-// RemovePermissionRequest indicates an expected call of RemovePermissionRequest.
-func (mr *MockSQSAPIMockRecorder) RemovePermissionRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionRequest", reflect.TypeOf((*MockSQSAPI)(nil).RemovePermissionRequest), arg0)
-}
-
-// RemovePermissionWithContext mocks base method.
-func (m *MockSQSAPI) RemovePermissionWithContext(arg0 context.Context, arg1 *sqs.RemovePermissionInput, arg2 ...request.Option) (*sqs.RemovePermissionOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RemovePermissionWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.RemovePermissionOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RemovePermissionWithContext indicates an expected call of RemovePermissionWithContext.
-func (mr *MockSQSAPIMockRecorder) RemovePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionWithContext", reflect.TypeOf((*MockSQSAPI)(nil).RemovePermissionWithContext), varargs...)
-}
-
-// SendMessage mocks base method.
-func (m *MockSQSAPI) SendMessage(arg0 *sqs.SendMessageInput) (*sqs.SendMessageOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendMessage", arg0)
-	ret0, _ := ret[0].(*sqs.SendMessageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SendMessage indicates an expected call of SendMessage.
-func (mr *MockSQSAPIMockRecorder) SendMessage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockSQSAPI)(nil).SendMessage), arg0)
-}
-
-// SendMessageBatch mocks base method.
-func (m *MockSQSAPI) SendMessageBatch(arg0 *sqs.SendMessageBatchInput) (*sqs.SendMessageBatchOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendMessageBatch", arg0)
-	ret0, _ := ret[0].(*sqs.SendMessageBatchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SendMessageBatch indicates an expected call of SendMessageBatch.
-func (mr *MockSQSAPIMockRecorder) SendMessageBatch(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatch", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageBatch), arg0)
-}
-
-// SendMessageBatchRequest mocks base method.
-func (m *MockSQSAPI) SendMessageBatchRequest(arg0 *sqs.SendMessageBatchInput) (*request.Request, *sqs.SendMessageBatchOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendMessageBatchRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.SendMessageBatchOutput)
-	return ret0, ret1
-}
-
-// SendMessageBatchRequest indicates an expected call of SendMessageBatchRequest.
-func (mr *MockSQSAPIMockRecorder) SendMessageBatchRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageBatchRequest), arg0)
-}
-
-// SendMessageBatchWithContext mocks base method.
-func (m *MockSQSAPI) SendMessageBatchWithContext(arg0 context.Context, arg1 *sqs.SendMessageBatchInput, arg2 ...request.Option) (*sqs.SendMessageBatchOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SendMessageBatchWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.SendMessageBatchOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SendMessageBatchWithContext indicates an expected call of SendMessageBatchWithContext.
-func (mr *MockSQSAPIMockRecorder) SendMessageBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatchWithContext", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageBatchWithContext), varargs...)
-}
-
-// SendMessageRequest mocks base method.
-func (m *MockSQSAPI) SendMessageRequest(arg0 *sqs.SendMessageInput) (*request.Request, *sqs.SendMessageOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendMessageRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.SendMessageOutput)
-	return ret0, ret1
-}
-
-// SendMessageRequest indicates an expected call of SendMessageRequest.
-func (mr *MockSQSAPIMockRecorder) SendMessageRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageRequest), arg0)
-}
-
-// SendMessageWithContext mocks base method.
-func (m *MockSQSAPI) SendMessageWithContext(arg0 context.Context, arg1 *sqs.SendMessageInput, arg2 ...request.Option) (*sqs.SendMessageOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SendMessageWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.SendMessageOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SendMessageWithContext indicates an expected call of SendMessageWithContext.
-func (mr *MockSQSAPIMockRecorder) SendMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageWithContext", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageWithContext), varargs...)
-}
-
-// SetQueueAttributes mocks base method.
-func (m *MockSQSAPI) SetQueueAttributes(arg0 *sqs.SetQueueAttributesInput) (*sqs.SetQueueAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetQueueAttributes", arg0)
-	ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput)
-	ret1, _ := ret[1].(error)
+	ret := m.ctrl.Call(m, "SetQueueAttributes", varargs...)
+	ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput)
+	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SetQueueAttributes indicates an expected call of SetQueueAttributes.
-func (mr *MockSQSAPIMockRecorder) SetQueueAttributes(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributes", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributes), arg0)
-}
-
-// SetQueueAttributesRequest mocks base method.
-func (m *MockSQSAPI) SetQueueAttributesRequest(arg0 *sqs.SetQueueAttributesInput) (*request.Request, *sqs.SetQueueAttributesOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetQueueAttributesRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.SetQueueAttributesOutput)
-	return ret0, ret1
-}
-
-// SetQueueAttributesRequest indicates an expected call of SetQueueAttributesRequest.
-func (mr *MockSQSAPIMockRecorder) SetQueueAttributesRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributesRequest", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributesRequest), arg0)
-}
-
-// SetQueueAttributesWithContext mocks base method.
-func (m *MockSQSAPI) SetQueueAttributesWithContext(arg0 context.Context, arg1 *sqs.SetQueueAttributesInput, arg2 ...request.Option) (*sqs.SetQueueAttributesOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SetQueueAttributesWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SetQueueAttributesWithContext indicates an expected call of SetQueueAttributesWithContext.
-func (mr *MockSQSAPIMockRecorder) SetQueueAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributesWithContext", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributesWithContext), varargs...)
-}
-
-// StartMessageMoveTask mocks base method.
-func (m *MockSQSAPI) StartMessageMoveTask(arg0 *sqs.StartMessageMoveTaskInput) (*sqs.StartMessageMoveTaskOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartMessageMoveTask", arg0)
-	ret0, _ := ret[0].(*sqs.StartMessageMoveTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartMessageMoveTask indicates an expected call of StartMessageMoveTask.
-func (mr *MockSQSAPIMockRecorder) StartMessageMoveTask(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMessageMoveTask", reflect.TypeOf((*MockSQSAPI)(nil).StartMessageMoveTask), arg0)
-}
-
-// StartMessageMoveTaskRequest mocks base method.
-func (m *MockSQSAPI) StartMessageMoveTaskRequest(arg0 *sqs.StartMessageMoveTaskInput) (*request.Request, *sqs.StartMessageMoveTaskOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartMessageMoveTaskRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.StartMessageMoveTaskOutput)
-	return ret0, ret1
-}
-
-// StartMessageMoveTaskRequest indicates an expected call of StartMessageMoveTaskRequest.
-func (mr *MockSQSAPIMockRecorder) StartMessageMoveTaskRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMessageMoveTaskRequest", reflect.TypeOf((*MockSQSAPI)(nil).StartMessageMoveTaskRequest), arg0)
-}
-
-// StartMessageMoveTaskWithContext mocks base method.
-func (m *MockSQSAPI) StartMessageMoveTaskWithContext(arg0 context.Context, arg1 *sqs.StartMessageMoveTaskInput, arg2 ...request.Option) (*sqs.StartMessageMoveTaskOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "StartMessageMoveTaskWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.StartMessageMoveTaskOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartMessageMoveTaskWithContext indicates an expected call of StartMessageMoveTaskWithContext.
-func (mr *MockSQSAPIMockRecorder) StartMessageMoveTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartMessageMoveTaskWithContext", reflect.TypeOf((*MockSQSAPI)(nil).StartMessageMoveTaskWithContext), varargs...)
-}
-
-// TagQueue mocks base method.
-func (m *MockSQSAPI) TagQueue(arg0 *sqs.TagQueueInput) (*sqs.TagQueueOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TagQueue", arg0)
-	ret0, _ := ret[0].(*sqs.TagQueueOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TagQueue indicates an expected call of TagQueue.
-func (mr *MockSQSAPIMockRecorder) TagQueue(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagQueue", reflect.TypeOf((*MockSQSAPI)(nil).TagQueue), arg0)
-}
-
-// TagQueueRequest mocks base method.
-func (m *MockSQSAPI) TagQueueRequest(arg0 *sqs.TagQueueInput) (*request.Request, *sqs.TagQueueOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TagQueueRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.TagQueueOutput)
-	return ret0, ret1
-}
-
-// TagQueueRequest indicates an expected call of TagQueueRequest.
-func (mr *MockSQSAPIMockRecorder) TagQueueRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).TagQueueRequest), arg0)
-}
-
-// TagQueueWithContext mocks base method.
-func (m *MockSQSAPI) TagQueueWithContext(arg0 context.Context, arg1 *sqs.TagQueueInput, arg2 ...request.Option) (*sqs.TagQueueOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "TagQueueWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.TagQueueOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// TagQueueWithContext indicates an expected call of TagQueueWithContext.
-func (mr *MockSQSAPIMockRecorder) TagQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagQueueWithContext", reflect.TypeOf((*MockSQSAPI)(nil).TagQueueWithContext), varargs...)
-}
-
-// UntagQueue mocks base method.
-func (m *MockSQSAPI) UntagQueue(arg0 *sqs.UntagQueueInput) (*sqs.UntagQueueOutput, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UntagQueue", arg0)
-	ret0, _ := ret[0].(*sqs.UntagQueueOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UntagQueue indicates an expected call of UntagQueue.
-func (mr *MockSQSAPIMockRecorder) UntagQueue(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagQueue", reflect.TypeOf((*MockSQSAPI)(nil).UntagQueue), arg0)
-}
-
-// UntagQueueRequest mocks base method.
-func (m *MockSQSAPI) UntagQueueRequest(arg0 *sqs.UntagQueueInput) (*request.Request, *sqs.UntagQueueOutput) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UntagQueueRequest", arg0)
-	ret0, _ := ret[0].(*request.Request)
-	ret1, _ := ret[1].(*sqs.UntagQueueOutput)
-	return ret0, ret1
-}
-
-// UntagQueueRequest indicates an expected call of UntagQueueRequest.
-func (mr *MockSQSAPIMockRecorder) UntagQueueRequest(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).UntagQueueRequest), arg0)
-}
-
-// UntagQueueWithContext mocks base method.
-func (m *MockSQSAPI) UntagQueueWithContext(arg0 context.Context, arg1 *sqs.UntagQueueInput, arg2 ...request.Option) (*sqs.UntagQueueOutput, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UntagQueueWithContext", varargs...)
-	ret0, _ := ret[0].(*sqs.UntagQueueOutput)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UntagQueueWithContext indicates an expected call of UntagQueueWithContext.
-func (mr *MockSQSAPIMockRecorder) UntagQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockSQSAPIMockRecorder) SetQueueAttributes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagQueueWithContext", reflect.TypeOf((*MockSQSAPI)(nil).UntagQueueWithContext), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributes", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributes), varargs...)
 }
diff --git a/pkg/cloud/services/instancestate/queue.go b/pkg/cloud/services/instancestate/queue.go
index 0e41a7c0b..20733a034 100644
--- a/pkg/cloud/services/instancestate/queue.go
+++ b/pkg/cloud/services/instancestate/queue.go
@@ -17,46 +17,47 @@ limitations under the License.
 package instancestate
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"strings"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/sqs"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	"github.com/pkg/errors"
 
 	iamv1 "sigs.k8s.io/cluster-api-provider-aws/v2/iam/api/v1beta1"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors"
 )
 
-func (s *Service) reconcileSQSQueue() error {
+func (s *Service) reconcileSQSQueue(ctx context.Context) error {
 	attrs := make(map[string]string)
-	attrs[sqs.QueueAttributeNameReceiveMessageWaitTimeSeconds] = "20"
+	attrs[string(sqstypes.QueueAttributeNameReceiveMessageWaitTimeSeconds)] = "20"
 
-	_, err := s.SQSClient.CreateQueue(&sqs.CreateQueueInput{
+	_, err := s.SQSClient.CreateQueue(ctx, &sqs.CreateQueueInput{
 		QueueName:  aws.String(GenerateQueueName(s.scope.Name())),
-		Attributes: aws.StringMap(attrs),
+		Attributes: attrs,
 	})
 
-	if err != nil {
-		if aerr, ok := err.(awserr.Error); ok {
-			if aerr.Code() == sqs.ErrCodeQueueNameExists {
-				return nil
-			}
+	smithyErr := awserrors.ParseSmithyError(err)
+	if smithyErr != nil {
+		if smithyErr.ErrorCode() == (&sqstypes.QueueNameExists{}).ErrorCode() {
+			return nil
 		}
 	}
 	return errors.Wrap(err, "unable to create new queue")
 }
 
-func (s *Service) deleteSQSQueue() error {
-	resp, err := s.SQSClient.GetQueueUrl(&sqs.GetQueueUrlInput{QueueName: aws.String(GenerateQueueName(s.scope.Name()))})
+func (s *Service) deleteSQSQueue(ctx context.Context) error {
+	resp, err := s.SQSClient.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{QueueName: aws.String(GenerateQueueName(s.scope.Name()))})
 	if err != nil {
 		if queueNotFoundError(err) {
 			return nil
 		}
 		return errors.Wrap(err, "unable to get queue URL")
 	}
-	_, err = s.SQSClient.DeleteQueue(&sqs.DeleteQueueInput{QueueUrl: resp.QueueUrl})
+	_, err = s.SQSClient.DeleteQueue(ctx, &sqs.DeleteQueueInput{QueueUrl: resp.QueueUrl})
 	if err != nil && queueNotFoundError(err) {
 		return nil
 	}
@@ -64,7 +65,7 @@ func (s *Service) deleteSQSQueue() error {
 	return errors.Wrap(err, "unable to delete queue")
 }
 
-func (s *Service) createPolicyForRule(input *createPolicyForRuleInput) error {
+func (s *Service) createPolicyForRule(ctx context.Context, input *createPolicyForRuleInput) error {
 	attrs := make(map[string]string)
 	policy := iamv1.PolicyDocument{
 		Version: iamv1.CurrentVersion,
@@ -86,11 +87,11 @@ func (s *Service) createPolicyForRule(input *createPolicyForRuleInput) error {
 	if err != nil {
 		return errors.Wrap(err, "unable to JSON marshal policy")
 	}
-	attrs[sqs.QueueAttributeNamePolicy] = string(policyData)
+	attrs[string(sqstypes.QueueAttributeNamePolicy)] = string(policyData)
 
-	_, err = s.SQSClient.SetQueueAttributes(&sqs.SetQueueAttributesInput{
+	_, err = s.SQSClient.SetQueueAttributes(ctx, &sqs.SetQueueAttributesInput{
 		QueueUrl:   aws.String(input.QueueURL),
-		Attributes: aws.StringMap(attrs),
+		Attributes: attrs,
 	})
 
 	return errors.Wrap(err, "unable to update queue attributes")
@@ -103,12 +104,11 @@ func GenerateQueueName(clusterName string) string {
 }
 
 func queueNotFoundError(err error) bool {
-	if aerr, ok := err.(awserr.Error); ok {
-		if aerr.Code() == sqs.ErrCodeQueueDoesNotExist {
-			return true
-		}
+	smithyErr := awserrors.ParseSmithyError(err)
+	if smithyErr == nil {
+		return false
 	}
-	return false
+	return smithyErr.ErrorCode() == (&sqstypes.QueueDoesNotExist{}).ErrorCode()
 }
 
 type createPolicyForRuleInput struct {
diff --git a/pkg/cloud/services/instancestate/rule.go b/pkg/cloud/services/instancestate/rule.go
index 9fc4d0972..4b95ee42a 100644
--- a/pkg/cloud/services/instancestate/rule.go
+++ b/pkg/cloud/services/instancestate/rule.go
@@ -17,25 +17,28 @@ limitations under the License.
 package instancestate
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/eventbridge"
-	"github.com/aws/aws-sdk-go/service/sqs"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/eventbridge"
+	eventbridgetypes "github.com/aws/aws-sdk-go-v2/service/eventbridge/types"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	"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/awserrors"
 )
 
 // Ec2StateChangeNotification defines the EC2 instance's state change notification.
 const Ec2StateChangeNotification = "EC2 Instance State-change Notification"
 
 // reconcileRules creates rules and attaches the queue as a target.
-func (s Service) reconcileRules() error {
+func (s Service) reconcileRules(ctx context.Context) error {
 	var ruleNotFound bool
-	ruleResp, err := s.EventBridgeClient.DescribeRule(&eventbridge.DescribeRuleInput{
+	ruleResp, err := s.EventBridgeClient.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 		Name: aws.String(s.getEC2RuleName()),
 	})
 	if err != nil {
@@ -47,12 +50,12 @@ func (s Service) reconcileRules() error {
 	}
 
 	if ruleNotFound {
-		err = s.createRule()
+		err = s.createRule(ctx)
 		if err != nil {
 			return errors.Wrap(err, "unable to create rule")
 		}
 		// fetch newly created rule
-		ruleResp, err = s.EventBridgeClient.DescribeRule(&eventbridge.DescribeRuleInput{
+		ruleResp, err = s.EventBridgeClient.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 			Name: aws.String(s.getEC2RuleName()),
 		})
 
@@ -61,15 +64,15 @@ func (s Service) reconcileRules() error {
 		}
 	}
 
-	queueURLResp, err := s.SQSClient.GetQueueUrl(&sqs.GetQueueUrlInput{
+	queueURLResp, err := s.SQSClient.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
 		QueueName: aws.String(GenerateQueueName(s.scope.Name())),
 	})
 
 	if err != nil {
 		return errors.Wrap(err, "unable to get queue URL")
 	}
-	queueAttrs, err := s.SQSClient.GetQueueAttributes(&sqs.GetQueueAttributesInput{
-		AttributeNames: aws.StringSlice([]string{sqs.QueueAttributeNameQueueArn, sqs.QueueAttributeNamePolicy}),
+	queueAttrs, err := s.SQSClient.GetQueueAttributes(ctx, &sqs.GetQueueAttributesInput{
+		AttributeNames: []sqstypes.QueueAttributeName{sqstypes.QueueAttributeNameQueueArn, sqstypes.QueueAttributeNamePolicy},
 		QueueUrl:       queueURLResp.QueueUrl,
 	})
 
@@ -77,7 +80,12 @@ func (s Service) reconcileRules() error {
 		return errors.Wrap(err, "unable to get queue attributes")
 	}
 
-	targetsResp, err := s.EventBridgeClient.ListTargetsByRule(&eventbridge.ListTargetsByRuleInput{
+	queueArn, ok := queueAttrs.Attributes[string(sqstypes.QueueAttributeNameQueueArn)]
+	if !ok {
+		return errors.New("queue ARN not exist in queue attributes response")
+	}
+
+	targetsResp, err := s.EventBridgeClient.ListTargetsByRule(ctx, &eventbridge.ListTargetsByRuleInput{
 		Rule: aws.String(s.getEC2RuleName()),
 	})
 	if err != nil {
@@ -87,16 +95,16 @@ func (s Service) reconcileRules() error {
 	targetFound := false
 	for _, target := range targetsResp.Targets {
 		// check if queue is already added as a target
-		if *target.Id == GenerateQueueName(s.scope.Name()) && *target.Arn == *queueAttrs.Attributes[sqs.QueueAttributeNameQueueArn] {
+		if *target.Id == GenerateQueueName(s.scope.Name()) && *target.Arn == queueArn {
 			targetFound = true
 		}
 	}
 
 	if !targetFound {
-		_, err = s.EventBridgeClient.PutTargets(&eventbridge.PutTargetsInput{
+		_, err = s.EventBridgeClient.PutTargets(ctx, &eventbridge.PutTargetsInput{
 			Rule: ruleResp.Name,
-			Targets: []*eventbridge.Target{{
-				Arn: queueAttrs.Attributes[sqs.QueueAttributeNameQueueArn],
+			Targets: []eventbridgetypes.Target{{
+				Arn: aws.String(queueArn),
 				Id:  aws.String(GenerateQueueName(s.scope.Name())),
 			}},
 		})
@@ -106,10 +114,10 @@ func (s Service) reconcileRules() error {
 		}
 	}
 
-	if queueAttrs.Attributes[sqs.QueueAttributeNamePolicy] == nil {
+	if _, ok := queueAttrs.Attributes[string(sqstypes.QueueAttributeNamePolicy)]; !ok {
 		// add a policy for the rule so the rule is authorized to emit messages to the queue
-		err = s.createPolicyForRule(&createPolicyForRuleInput{
-			QueueArn: *queueAttrs.Attributes[sqs.QueueAttributeNameQueueArn],
+		err = s.createPolicyForRule(ctx, &createPolicyForRuleInput{
+			QueueArn: queueArn,
 			QueueURL: *queueURLResp.QueueUrl,
 			RuleArn:  *ruleResp.Arn,
 		})
@@ -121,7 +129,7 @@ func (s Service) reconcileRules() error {
 	return nil
 }
 
-func (s Service) createRule() error {
+func (s Service) createRule(ctx context.Context) error {
 	eventPattern := eventPattern{
 		Source:     []string{"aws.ec2"},
 		DetailType: []string{Ec2StateChangeNotification},
@@ -135,24 +143,24 @@ func (s Service) createRule() error {
 	}
 	// create in disabled state so the rule doesn't pick up all EC2 instances. As machines get created,
 	// the rule will get updated to track those machines
-	_, err = s.EventBridgeClient.PutRule(&eventbridge.PutRuleInput{
+	_, err = s.EventBridgeClient.PutRule(ctx, &eventbridge.PutRuleInput{
 		Name:         aws.String(s.getEC2RuleName()),
 		EventPattern: aws.String(string(data)),
-		State:        aws.String(eventbridge.RuleStateDisabled),
+		State:        eventbridgetypes.RuleStateDisabled,
 	})
 
 	return err
 }
 
-func (s Service) deleteRules() error {
-	_, err := s.EventBridgeClient.RemoveTargets(&eventbridge.RemoveTargetsInput{
+func (s Service) deleteRules(ctx context.Context) error {
+	_, err := s.EventBridgeClient.RemoveTargets(ctx, &eventbridge.RemoveTargetsInput{
 		Rule: aws.String(s.getEC2RuleName()),
-		Ids:  aws.StringSlice([]string{GenerateQueueName(s.scope.Name())}),
+		Ids:  []string{GenerateQueueName(s.scope.Name())},
 	})
 	if err != nil && !resourceNotFoundError(err) {
 		return errors.Wrapf(err, "unable to remove target %s for rule %s", GenerateQueueName(s.scope.Name()), s.getEC2RuleName())
 	}
-	_, err = s.EventBridgeClient.DeleteRule(&eventbridge.DeleteRuleInput{
+	_, err = s.EventBridgeClient.DeleteRule(ctx, &eventbridge.DeleteRuleInput{
 		Name: aws.String(s.getEC2RuleName()),
 	})
 
@@ -164,8 +172,8 @@ func (s Service) deleteRules() error {
 }
 
 // AddInstanceToEventPattern will add an instance to an event pattern.
-func (s Service) AddInstanceToEventPattern(instanceID string) error {
-	ruleResp, err := s.EventBridgeClient.DescribeRule(&eventbridge.DescribeRuleInput{
+func (s Service) AddInstanceToEventPattern(ctx context.Context, instanceID string) error {
+	ruleResp, err := s.EventBridgeClient.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 		Name: aws.String(s.getEC2RuleName()),
 	})
 	if err != nil {
@@ -190,18 +198,18 @@ func (s Service) AddInstanceToEventPattern(instanceID string) error {
 	if err != nil {
 		return err
 	}
-	_, err = s.EventBridgeClient.PutRule(&eventbridge.PutRuleInput{
+	_, err = s.EventBridgeClient.PutRule(ctx, &eventbridge.PutRuleInput{
 		Name:         aws.String(s.getEC2RuleName()),
 		EventPattern: aws.String(string(eventData)),
-		State:        aws.String(eventbridge.RuleStateEnabled),
+		State:        eventbridgetypes.RuleStateEnabled,
 	})
 	return err
 }
 
 // RemoveInstanceFromEventPattern attempts a best effort update to the event rule to remove the instance.
 // Any errors encountered won't be blocking.
-func (s Service) RemoveInstanceFromEventPattern(instanceID string) {
-	ruleResp, err := s.EventBridgeClient.DescribeRule(&eventbridge.DescribeRuleInput{
+func (s Service) RemoveInstanceFromEventPattern(ctx context.Context, instanceID string) {
+	ruleResp, err := s.EventBridgeClient.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 		Name: aws.String(s.getEC2RuleName()),
 	})
 	if err != nil {
@@ -231,13 +239,13 @@ func (s Service) RemoveInstanceFromEventPattern(instanceID string) {
 		input := &eventbridge.PutRuleInput{
 			Name:         aws.String(s.getEC2RuleName()),
 			EventPattern: aws.String(string(eventData)),
-			State:        aws.String(eventbridge.RuleStateEnabled),
+			State:        eventbridgetypes.RuleStateEnabled,
 		}
 
 		if len(e.EventDetail.InstanceIDs) == 0 {
-			input.State = aws.String(eventbridge.RuleStateDisabled)
+			input.State = eventbridgetypes.RuleStateDisabled
 		}
-		_, _ = s.EventBridgeClient.PutRule(input)
+		_, _ = s.EventBridgeClient.PutRule(ctx, input)
 	}
 }
 
@@ -246,10 +254,11 @@ func (s Service) getEC2RuleName() string {
 }
 
 func resourceNotFoundError(err error) bool {
-	if aerr, ok := err.(awserr.Error); ok && aerr.Code() == eventbridge.ErrCodeResourceNotFoundException {
-		return true
+	smithyErr := awserrors.ParseSmithyError(err)
+	if smithyErr == nil {
+		return false
 	}
-	return false
+	return smithyErr.ErrorCode() == (&eventbridgetypes.ResourceNotFoundException{}).ErrorCode()
 }
 
 type eventPattern struct {
diff --git a/pkg/cloud/services/instancestate/service.go b/pkg/cloud/services/instancestate/service.go
index b798967ff..8b4d90c62 100644
--- a/pkg/cloud/services/instancestate/service.go
+++ b/pkg/cloud/services/instancestate/service.go
@@ -18,8 +18,10 @@ limitations under the License.
 package instancestate
 
 import (
-	"github.com/aws/aws-sdk-go/service/eventbridge/eventbridgeiface"
-	"github.com/aws/aws-sdk-go/service/sqs/sqsiface"
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/service/eventbridge"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
 
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
 )
@@ -27,8 +29,29 @@ import (
 // Service defines the specs for a service.
 type Service struct {
 	scope             scope.EC2Scope
-	EventBridgeClient eventbridgeiface.EventBridgeAPI
-	SQSClient         sqsiface.SQSAPI
+	EventBridgeClient EventBridgeAPI
+	SQSClient         SQSAPI
+}
+
+// SQSAPI is the subset of the AWS SQS API used by CAPA.
+type SQSAPI interface {
+	CreateQueue(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error)
+	DeleteMessage(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error)
+	DeleteQueue(ctx context.Context, params *sqs.DeleteQueueInput, optFns ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error)
+	GetQueueAttributes(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error)
+	GetQueueUrl(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error)
+	ReceiveMessage(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error)
+	SetQueueAttributes(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error)
+}
+
+// EventBridgeAPI is the subset of the AWS EventBridge API used by CAPA.
+type EventBridgeAPI interface {
+	DeleteRule(ctx context.Context, params *eventbridge.DeleteRuleInput, optFns ...func(*eventbridge.Options)) (*eventbridge.DeleteRuleOutput, error)
+	DescribeRule(ctx context.Context, params *eventbridge.DescribeRuleInput, optFns ...func(*eventbridge.Options)) (*eventbridge.DescribeRuleOutput, error)
+	ListTargetsByRule(ctx context.Context, params *eventbridge.ListTargetsByRuleInput, optFns ...func(*eventbridge.Options)) (*eventbridge.ListTargetsByRuleOutput, error)
+	PutRule(ctx context.Context, params *eventbridge.PutRuleInput, optFns ...func(*eventbridge.Options)) (*eventbridge.PutRuleOutput, error)
+	PutTargets(ctx context.Context, params *eventbridge.PutTargetsInput, optFns ...func(*eventbridge.Options)) (*eventbridge.PutTargetsOutput, error)
+	RemoveTargets(ctx context.Context, params *eventbridge.RemoveTargetsInput, optFns ...func(*eventbridge.Options)) (*eventbridge.RemoveTargetsOutput, error)
 }
 
 // NewService returns a new service given the ec2 api client.



Test patch:
diff --git a/exp/instancestate/awsinstancestate_controller_test.go b/exp/instancestate/awsinstancestate_controller_test.go
index 0c015b6de..aa81a052e 100644
--- a/exp/instancestate/awsinstancestate_controller_test.go
+++ b/exp/instancestate/awsinstancestate_controller_test.go
@@ -22,9 +22,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/sqs"
-	"github.com/aws/aws-sdk-go/service/sqs/sqsiface"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -36,6 +36,7 @@ import (
 
 	infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/controllers"
+	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/instancestate"
 	"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/instancestate/mock_sqsiface"
 )
 
@@ -45,7 +46,7 @@ func TestAWSInstanceStateController(t *testing.T) {
 	instanceStateReconciler = &AwsInstanceStateReconciler{
 		Client: testEnv.Client,
 		Log:    ctrl.Log.WithName("controllers").WithName("AWSInstanceState"),
-		sqsServiceFactory: func() sqsiface.SQSAPI {
+		sqsServiceFactory: func() instancestate.SQSAPI {
 			return sqsSvs
 		},
 	}
@@ -58,38 +59,38 @@ func TestAWSInstanceStateController(t *testing.T) {
 			Name:      "aws-cluster-1-instance-1",
 			Namespace: "default",
 		}
-		sqsSvs.EXPECT().GetQueueUrl(&sqs.GetQueueUrlInput{QueueName: aws.String("aws-cluster-1-queue")}).AnyTimes().
+		sqsSvs.EXPECT().GetQueueUrl(gomock.Any(), &sqs.GetQueueUrlInput{QueueName: aws.String("aws-cluster-1-queue")}).AnyTimes().
 			Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("aws-cluster-1-url")}, nil)
-		sqsSvs.EXPECT().GetQueueUrl(&sqs.GetQueueUrlInput{QueueName: aws.String("aws-cluster-2-queue")}).AnyTimes().
+		sqsSvs.EXPECT().GetQueueUrl(gomock.Any(), &sqs.GetQueueUrlInput{QueueName: aws.String("aws-cluster-2-queue")}).AnyTimes().
 			Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("aws-cluster-2-url")}, nil)
-		sqsSvs.EXPECT().GetQueueUrl(&sqs.GetQueueUrlInput{QueueName: aws.String("aws-cluster-3-queue")}).AnyTimes().
+		sqsSvs.EXPECT().GetQueueUrl(gomock.Any(), &sqs.GetQueueUrlInput{QueueName: aws.String("aws-cluster-3-queue")}).AnyTimes().
 			Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("aws-cluster-3-url")}, nil)
-		sqsSvs.EXPECT().ReceiveMessage(&sqs.ReceiveMessageInput{QueueUrl: aws.String("aws-cluster-1-url")}).AnyTimes().
-			DoAndReturn(func(arg *sqs.ReceiveMessageInput) (*sqs.ReceiveMessageOutput, error) {
+		sqsSvs.EXPECT().ReceiveMessage(gomock.Any(), &sqs.ReceiveMessageInput{QueueUrl: aws.String("aws-cluster-1-url")}).AnyTimes().
+			DoAndReturn(func(ctx context.Context, arg *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error) {
 				m := &infrav1.AWSMachine{}
 				lookupKey := types.NamespacedName{
 					Namespace: failingMachineMeta.Namespace,
 					Name:      failingMachineMeta.Name,
 				}
-				err := k8sClient.Get(context.TODO(), lookupKey, m)
+				err := k8sClient.Get(ctx, lookupKey, m)
 				// start returning a message once the AWSMachine is available
 				if err == nil {
 					return &sqs.ReceiveMessageOutput{
-						Messages: []*sqs.Message{{
+						Messages: []sqstypes.Message{{
 							ReceiptHandle: aws.String("message-receipt-handle"),
 							Body:          aws.String(messageBodyJSON),
 						}},
 					}, nil
 				}
 
-				return &sqs.ReceiveMessageOutput{Messages: []*sqs.Message{}}, nil
+				return &sqs.ReceiveMessageOutput{Messages: []sqstypes.Message{}}, nil
 			})
 
-		sqsSvs.EXPECT().ReceiveMessage(&sqs.ReceiveMessageInput{QueueUrl: aws.String("aws-cluster-2-url")}).AnyTimes().
-			Return(&sqs.ReceiveMessageOutput{Messages: []*sqs.Message{}}, nil)
-		sqsSvs.EXPECT().ReceiveMessage(&sqs.ReceiveMessageInput{QueueUrl: aws.String("aws-cluster-3-url")}).AnyTimes().
-			Return(&sqs.ReceiveMessageOutput{Messages: []*sqs.Message{}}, nil)
-		sqsSvs.EXPECT().DeleteMessage(&sqs.DeleteMessageInput{QueueUrl: aws.String("aws-cluster-1-url"), ReceiptHandle: aws.String("message-receipt-handle")}).AnyTimes().
+		sqsSvs.EXPECT().ReceiveMessage(gomock.Any(), &sqs.ReceiveMessageInput{QueueUrl: aws.String("aws-cluster-2-url")}).AnyTimes().
+			Return(&sqs.ReceiveMessageOutput{Messages: []sqstypes.Message{}}, nil)
+		sqsSvs.EXPECT().ReceiveMessage(gomock.Any(), &sqs.ReceiveMessageInput{QueueUrl: aws.String("aws-cluster-3-url")}).AnyTimes().
+			Return(&sqs.ReceiveMessageOutput{Messages: []sqstypes.Message{}}, nil)
+		sqsSvs.EXPECT().DeleteMessage(gomock.Any(), &sqs.DeleteMessageInput{QueueUrl: aws.String("aws-cluster-1-url"), ReceiptHandle: aws.String("message-receipt-handle")}).AnyTimes().
 			Return(nil, nil)
 
 		g.Expect(testEnv.Manager.GetFieldIndexer().IndexField(context.Background(), &infrav1.AWSMachine{},
diff --git a/pkg/cloud/services/instancestate/queue_test.go b/pkg/cloud/services/instancestate/queue_test.go
index ae1a26ff2..d1fdfb458 100644
--- a/pkg/cloud/services/instancestate/queue_test.go
+++ b/pkg/cloud/services/instancestate/queue_test.go
@@ -18,12 +18,13 @@ package instancestate
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/sqs"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -35,6 +36,8 @@ func TestReconcileSQSQueue(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 
+	ctx := context.TODO()
+
 	testCases := []struct {
 		name      string
 		expect    func(m *mock_sqsiface.MockSQSAPIMockRecorder)
@@ -44,10 +47,10 @@ func TestReconcileSQSQueue(t *testing.T) {
 			name: "successfully creates an SQS queue",
 			expect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
 				attrs := make(map[string]string)
-				attrs[sqs.QueueAttributeNameReceiveMessageWaitTimeSeconds] = "20"
-				m.CreateQueue(&sqs.CreateQueueInput{
+				attrs[string(sqstypes.QueueAttributeNameReceiveMessageWaitTimeSeconds)] = "20"
+				m.CreateQueue(ctx, &sqs.CreateQueueInput{
 					QueueName:  aws.String("test-cluster-queue"),
-					Attributes: aws.StringMap(attrs),
+					Attributes: attrs,
 				}).Return(nil, nil)
 			},
 			expectErr: false,
@@ -56,11 +59,11 @@ func TestReconcileSQSQueue(t *testing.T) {
 			name: "does not error if queue already exists",
 			expect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
 				attrs := make(map[string]string)
-				attrs[sqs.QueueAttributeNameReceiveMessageWaitTimeSeconds] = "20"
-				m.CreateQueue(&sqs.CreateQueueInput{
+				attrs[string(sqstypes.QueueAttributeNameReceiveMessageWaitTimeSeconds)] = "20"
+				m.CreateQueue(ctx, &sqs.CreateQueueInput{
 					QueueName:  aws.String("test-cluster-queue"),
-					Attributes: aws.StringMap(attrs),
-				}).Return(nil, awserr.New(sqs.ErrCodeQueueNameExists, "", nil))
+					Attributes: attrs,
+				}).Return(nil, &sqstypes.QueueNameExists{})
 			},
 			expectErr: false,
 		},
@@ -68,10 +71,10 @@ func TestReconcileSQSQueue(t *testing.T) {
 			name: "errors when unexpected error occurs",
 			expect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
 				attrs := make(map[string]string)
-				attrs[sqs.QueueAttributeNameReceiveMessageWaitTimeSeconds] = "20"
-				m.CreateQueue(&sqs.CreateQueueInput{
+				attrs[string(sqstypes.QueueAttributeNameReceiveMessageWaitTimeSeconds)] = "20"
+				m.CreateQueue(ctx, &sqs.CreateQueueInput{
 					QueueName:  aws.String("test-cluster-queue"),
-					Attributes: aws.StringMap(attrs),
+					Attributes: attrs,
 				}).Return(nil, errors.New("some error"))
 			},
 			expectErr: true,
@@ -89,7 +92,7 @@ func TestReconcileSQSQueue(t *testing.T) {
 			s := NewService(clusterScope)
 			s.SQSClient = sqsMock
 
-			err = s.reconcileSQSQueue()
+			err = s.reconcileSQSQueue(ctx)
 
 			if tc.expectErr {
 				g.Expect(err).NotTo(BeNil())
@@ -104,6 +107,8 @@ func TestDeleteSQSQueue(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 
+	ctx := context.TODO()
+
 	testCases := []struct {
 		name      string
 		expect    func(m *mock_sqsiface.MockSQSAPIMockRecorder)
@@ -112,10 +117,10 @@ func TestDeleteSQSQueue(t *testing.T) {
 		{
 			name: "deletes queue successfully",
 			expect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
-				m.GetQueueUrl(&sqs.GetQueueUrlInput{
+				m.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
 					QueueName: aws.String("test-cluster-queue"),
 				}).Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("test-cluster-queue-url")}, nil)
-				m.DeleteQueue(&sqs.DeleteQueueInput{
+				m.DeleteQueue(ctx, &sqs.DeleteQueueInput{
 					QueueUrl: aws.String("test-cluster-queue-url"),
 				}).Return(nil, nil)
 			},
@@ -124,16 +129,16 @@ func TestDeleteSQSQueue(t *testing.T) {
 		{
 			name: "doesn't return error if queue not found when calling GetQueueUrl",
 			expect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
-				m.GetQueueUrl(&sqs.GetQueueUrlInput{
+				m.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
 					QueueName: aws.String("test-cluster-queue"),
-				}).Return(nil, awserr.New(sqs.ErrCodeQueueDoesNotExist, "", nil))
+				}).Return(nil, &sqstypes.QueueDoesNotExist{})
 			},
 			expectErr: false,
 		},
 		{
 			name: "returns error if Describe Queue failed for unexpected reason",
 			expect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
-				m.GetQueueUrl(&sqs.GetQueueUrlInput{
+				m.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
 					QueueName: aws.String("test-cluster-queue"),
 				}).Return(nil, errors.New("some error"))
 			},
@@ -142,22 +147,22 @@ func TestDeleteSQSQueue(t *testing.T) {
 		{
 			name: "doesn't return error if queue not found when attempting delete",
 			expect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
-				m.GetQueueUrl(&sqs.GetQueueUrlInput{
+				m.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
 					QueueName: aws.String("test-cluster-queue"),
 				}).Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("test-cluster-queue-url")}, nil)
-				m.DeleteQueue(&sqs.DeleteQueueInput{
+				m.DeleteQueue(ctx, &sqs.DeleteQueueInput{
 					QueueUrl: aws.String("test-cluster-queue-url"),
-				}).Return(nil, awserr.New(sqs.ErrCodeQueueDoesNotExist, "", nil))
+				}).Return(nil, &sqstypes.QueueDoesNotExist{})
 			},
 			expectErr: false,
 		},
 		{
 			name: "returns error if delete queue failed for unexpected reason",
 			expect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
-				m.GetQueueUrl(&sqs.GetQueueUrlInput{
+				m.GetQueueUrl(ctx, &sqs.GetQueueUrlInput{
 					QueueName: aws.String("test-cluster-queue"),
 				}).Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("test-cluster-queue-url")}, nil)
-				m.DeleteQueue(&sqs.DeleteQueueInput{
+				m.DeleteQueue(ctx, &sqs.DeleteQueueInput{
 					QueueUrl: aws.String("test-cluster-queue-url"),
 				}).Return(nil, errors.New("some error"))
 			},
@@ -176,7 +181,7 @@ func TestDeleteSQSQueue(t *testing.T) {
 			s := NewService(clusterScope)
 			s.SQSClient = sqsMock
 
-			err = s.deleteSQSQueue()
+			err = s.deleteSQSQueue(ctx)
 
 			if tc.expectErr {
 				g.Expect(err).NotTo(BeNil())
@@ -191,6 +196,8 @@ func TestCreatePolicyForRule(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 
+	ctx := context.TODO()
+
 	testCases := []struct {
 		name      string
 		input     *createPolicyForRuleInput
@@ -208,10 +215,10 @@ func TestCreatePolicyForRule(t *testing.T) {
 				buffer := new(bytes.Buffer)
 				_ = json.Compact(buffer, []byte(expectedPolicyJSON))
 				attrs := make(map[string]string)
-				attrs[sqs.QueueAttributeNamePolicy] = buffer.String()
-				m.SetQueueAttributes(&sqs.SetQueueAttributesInput{
+				attrs[string(sqstypes.QueueAttributeNamePolicy)] = buffer.String()
+				m.SetQueueAttributes(ctx, &sqs.SetQueueAttributesInput{
 					QueueUrl:   aws.String("test-cluster-queue-url"),
-					Attributes: aws.StringMap(attrs),
+					Attributes: attrs,
 				}).Return(nil, nil)
 			},
 			expectErr: false,
@@ -229,7 +236,7 @@ func TestCreatePolicyForRule(t *testing.T) {
 			s := NewService(clusterScope)
 			s.SQSClient = sqsMock
 
-			err = s.createPolicyForRule(tc.input)
+			err = s.createPolicyForRule(ctx, tc.input)
 
 			if tc.expectErr {
 				g.Expect(err).NotTo(BeNil())
diff --git a/pkg/cloud/services/instancestate/rule_test.go b/pkg/cloud/services/instancestate/rule_test.go
index d3d59cefe..984f144a5 100644
--- a/pkg/cloud/services/instancestate/rule_test.go
+++ b/pkg/cloud/services/instancestate/rule_test.go
@@ -17,13 +17,15 @@ limitations under the License.
 package instancestate
 
 import (
+	"context"
 	"encoding/json"
 	"testing"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/service/eventbridge"
-	"github.com/aws/aws-sdk-go/service/sqs"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/eventbridge"
+	eventbridgetypes "github.com/aws/aws-sdk-go-v2/service/eventbridge/types"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	sqstypes "github.com/aws/aws-sdk-go-v2/service/sqs/types"
 	"github.com/golang/mock/gomock"
 	. "github.com/onsi/gomega"
 	"github.com/pkg/errors"
@@ -37,6 +39,7 @@ func TestReconcileRules(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	ruleName := "test-cluster-ec2-rule"
+	ctx := context.TODO()
 
 	testCases := []struct {
 		name                        string
@@ -48,9 +51,9 @@ func TestReconcileRules(t *testing.T) {
 		{
 			name: "successfully creates missing rule and target",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.DescribeRule(gomock.Eq(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, gomock.Eq(&eventbridge.DescribeRuleInput{
 					Name: aws.String(ruleName),
-				})).Return(nil, awserr.New(eventbridge.ErrCodeResourceNotFoundException, "", nil))
+				})).Return(nil, &eventbridgetypes.ResourceNotFoundException{})
 				e := &eventPattern{
 					Source:     []string{"aws.ec2"},
 					DetailType: []string{Ec2StateChangeNotification},
@@ -62,54 +65,54 @@ func TestReconcileRules(t *testing.T) {
 				if err != nil {
 					t.Fatalf("got an unexpected error: %v", err)
 				}
-				m.PutRule(gomock.Eq(&eventbridge.PutRuleInput{
+				m.PutRule(ctx, gomock.Eq(&eventbridge.PutRuleInput{
 					Name:         aws.String(ruleName),
-					State:        aws.String(eventbridge.RuleStateDisabled),
+					State:        eventbridgetypes.RuleStateDisabled,
 					EventPattern: aws.String(string(data)),
 				}))
 			},
 			postCreateEventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.DescribeRule(gomock.Eq(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, gomock.Eq(&eventbridge.DescribeRuleInput{
 					Name: aws.String(ruleName),
 				})).Return(&eventbridge.DescribeRuleOutput{Name: aws.String(ruleName), Arn: aws.String("rule-arn")}, nil)
-				m.ListTargetsByRule(&eventbridge.ListTargetsByRuleInput{
+				m.ListTargetsByRule(ctx, &eventbridge.ListTargetsByRuleInput{
 					Rule: aws.String(ruleName),
 				}).Return(&eventbridge.ListTargetsByRuleOutput{
-					Targets: []*eventbridge.Target{{
+					Targets: []eventbridgetypes.Target{{
 						Id:  aws.String("another-queue"),
 						Arn: aws.String("another-queue-arn"),
 					}},
 				}, nil)
-				m.PutTargets(gomock.Eq(&eventbridge.PutTargetsInput{
+				m.PutTargets(ctx, gomock.Eq(&eventbridge.PutTargetsInput{
 					Rule: aws.String(ruleName),
-					Targets: []*eventbridge.Target{{
+					Targets: []eventbridgetypes.Target{{
 						Arn: aws.String("test-cluster-queue-arn"),
 						Id:  aws.String("test-cluster-queue"),
 					}},
 				}))
 			},
 			sqsExpect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
-				m.GetQueueUrl(gomock.Eq(&sqs.GetQueueUrlInput{
+				m.GetQueueUrl(ctx, gomock.Eq(&sqs.GetQueueUrlInput{
 					QueueName: aws.String("test-cluster-queue"),
 				})).Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("test-cluster-queue-url")}, nil)
 				attrs := make(map[string]string)
-				attrs[sqs.QueueAttributeNameQueueArn] = "test-cluster-queue-arn"
-				m.GetQueueAttributes(gomock.Eq(&sqs.GetQueueAttributesInput{
-					AttributeNames: aws.StringSlice([]string{sqs.QueueAttributeNameQueueArn, sqs.QueueAttributeNamePolicy}),
+				attrs[string(sqstypes.QueueAttributeNameQueueArn)] = "test-cluster-queue-arn"
+				m.GetQueueAttributes(ctx, gomock.Eq(&sqs.GetQueueAttributesInput{
+					AttributeNames: []sqstypes.QueueAttributeName{sqstypes.QueueAttributeNameQueueArn, sqstypes.QueueAttributeNamePolicy},
 					QueueUrl:       aws.String("test-cluster-queue-url"),
-				})).Return(&sqs.GetQueueAttributesOutput{Attributes: aws.StringMap(attrs)}, nil)
-				m.SetQueueAttributes(gomock.AssignableToTypeOf(&sqs.SetQueueAttributesInput{})).Return(nil, nil)
+				})).Return(&sqs.GetQueueAttributesOutput{Attributes: attrs}, nil)
+				m.SetQueueAttributes(ctx, gomock.AssignableToTypeOf(&sqs.SetQueueAttributesInput{})).Return(nil, nil)
 			},
 			expectErr: false,
 		},
 		{
 			name: "skips creating target and queue policy if they already exist",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.DescribeRule(gomock.Eq(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, gomock.Eq(&eventbridge.DescribeRuleInput{
 					Name: aws.String(ruleName),
 				})).Return(&eventbridge.DescribeRuleOutput{Name: aws.String(ruleName), Arn: aws.String("rule-arn")}, nil)
-				m.ListTargetsByRule(gomock.AssignableToTypeOf(&eventbridge.ListTargetsByRuleInput{})).Return(&eventbridge.ListTargetsByRuleOutput{
-					Targets: []*eventbridge.Target{{
+				m.ListTargetsByRule(ctx, gomock.AssignableToTypeOf(&eventbridge.ListTargetsByRuleInput{})).Return(&eventbridge.ListTargetsByRuleOutput{
+					Targets: []eventbridgetypes.Target{{
 						Id:  aws.String("test-cluster-queue"),
 						Arn: aws.String("test-cluster-queue-arn"),
 					}},
@@ -117,17 +120,32 @@ func TestReconcileRules(t *testing.T) {
 			},
 			postCreateEventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {},
 			sqsExpect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
-				m.GetQueueUrl(gomock.AssignableToTypeOf(&sqs.GetQueueUrlInput{})).Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("test-cluster-queue-url")}, nil)
+				m.GetQueueUrl(ctx, gomock.AssignableToTypeOf(&sqs.GetQueueUrlInput{})).Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("test-cluster-queue-url")}, nil)
 				attrs := make(map[string]string)
-				attrs[sqs.QueueAttributeNameQueueArn] = "test-cluster-queue-arn"
-				attrs[sqs.QueueAttributeNamePolicy] = "some policy"
-				m.GetQueueAttributes(gomock.AssignableToTypeOf(&sqs.GetQueueAttributesInput{})).Return(&sqs.GetQueueAttributesOutput{Attributes: aws.StringMap(attrs)}, nil)
+				attrs[string(sqstypes.QueueAttributeNameQueueArn)] = "test-cluster-queue-arn"
+				attrs[string(sqstypes.QueueAttributeNamePolicy)] = "some policy"
+				m.GetQueueAttributes(ctx, gomock.AssignableToTypeOf(&sqs.GetQueueAttributesInput{})).Return(&sqs.GetQueueAttributesOutput{Attributes: attrs}, nil)
 			},
 		},
+		{
+			name: "returns error if GetQueueAttributes doesn't have queue ARN",
+			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
+				m.DescribeRule(ctx, gomock.Eq(&eventbridge.DescribeRuleInput{
+					Name: aws.String(ruleName),
+				})).Return(&eventbridge.DescribeRuleOutput{Name: aws.String(ruleName), Arn: aws.String("rule-arn")}, nil)
+			},
+			postCreateEventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {},
+			sqsExpect: func(m *mock_sqsiface.MockSQSAPIMockRecorder) {
+				m.GetQueueUrl(ctx, gomock.AssignableToTypeOf(&sqs.GetQueueUrlInput{})).Return(&sqs.GetQueueUrlOutput{QueueUrl: aws.String("test-cluster-queue-url")}, nil)
+				attrs := make(map[string]string)
+				m.GetQueueAttributes(ctx, gomock.AssignableToTypeOf(&sqs.GetQueueAttributesInput{})).Return(&sqs.GetQueueAttributesOutput{Attributes: attrs}, nil)
+			},
+			expectErr: true,
+		},
 		{
 			name: "returns error if DescribeRule runs into unexpected error",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.DescribeRule(gomock.Eq(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, gomock.Eq(&eventbridge.DescribeRuleInput{
 					Name: aws.String(ruleName),
 				})).Return(nil, errors.New("some error"))
 			},
@@ -152,7 +170,7 @@ func TestReconcileRules(t *testing.T) {
 			s.EventBridgeClient = eventbridgeMock
 			s.SQSClient = sqsMock
 
-			err = s.reconcileRules()
+			err = s.reconcileRules(ctx)
 			if tc.expectErr {
 				g.Expect(err).NotTo(BeNil())
 			} else {
@@ -166,6 +184,8 @@ func TestDeleteRules(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 
+	ctx := context.TODO()
+
 	testCases := []struct {
 		name              string
 		eventBridgeExpect func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder)
@@ -174,11 +194,11 @@ func TestDeleteRules(t *testing.T) {
 		{
 			name: "removes target and ec2 rule successfully when they both exist",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.RemoveTargets(gomock.Eq(&eventbridge.RemoveTargetsInput{
+				m.RemoveTargets(ctx, gomock.Eq(&eventbridge.RemoveTargetsInput{
 					Rule: aws.String("test-cluster-ec2-rule"),
-					Ids:  aws.StringSlice([]string{"test-cluster-queue"}),
+					Ids:  []string{"test-cluster-queue"},
 				})).Return(nil, nil)
-				m.DeleteRule(gomock.Eq(&eventbridge.DeleteRuleInput{
+				m.DeleteRule(ctx, gomock.Eq(&eventbridge.DeleteRuleInput{
 					Name: aws.String("test-cluster-ec2-rule"),
 				})).Return(nil, nil)
 			},
@@ -187,9 +207,9 @@ func TestDeleteRules(t *testing.T) {
 		{
 			name: "continues to remove rule when target doesn't exist",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.RemoveTargets(gomock.AssignableToTypeOf(&eventbridge.RemoveTargetsInput{})).
-					Return(nil, awserr.New(eventbridge.ErrCodeResourceNotFoundException, "", nil))
-				m.DeleteRule(gomock.Eq(&eventbridge.DeleteRuleInput{
+				m.RemoveTargets(ctx, gomock.AssignableToTypeOf(&eventbridge.RemoveTargetsInput{})).
+					Return(nil, &eventbridgetypes.ResourceNotFoundException{})
+				m.DeleteRule(ctx, gomock.Eq(&eventbridge.DeleteRuleInput{
 					Name: aws.String("test-cluster-ec2-rule"),
 				})).Return(nil, nil)
 			},
@@ -198,15 +218,15 @@ func TestDeleteRules(t *testing.T) {
 		{
 			name: "returns error when remove target fails unexpectedly",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.RemoveTargets(gomock.AssignableToTypeOf(&eventbridge.RemoveTargetsInput{})).Return(nil, errors.New("some error"))
+				m.RemoveTargets(ctx, gomock.AssignableToTypeOf(&eventbridge.RemoveTargetsInput{})).Return(nil, errors.New("some error"))
 			},
 			expectErr: true,
 		},
 		{
 			name: "returns error when delete rule fails unexpectedly",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.RemoveTargets(gomock.AssignableToTypeOf(&eventbridge.RemoveTargetsInput{})).Return(nil, nil)
-				m.DeleteRule(gomock.AssignableToTypeOf(&eventbridge.DeleteRuleInput{})).Return(nil, errors.New("some error"))
+				m.RemoveTargets(ctx, gomock.AssignableToTypeOf(&eventbridge.RemoveTargetsInput{})).Return(nil, nil)
+				m.DeleteRule(ctx, gomock.AssignableToTypeOf(&eventbridge.DeleteRuleInput{})).Return(nil, errors.New("some error"))
 			},
 			expectErr: true,
 		},
@@ -223,7 +243,7 @@ func TestDeleteRules(t *testing.T) {
 			s := NewService(clusterScope)
 			s.EventBridgeClient = eventbridgeMock
 
-			err = s.deleteRules()
+			err = s.deleteRules(ctx)
 			if tc.expectErr {
 				g.Expect(err).NotTo(BeNil())
 			} else {
@@ -248,6 +268,8 @@ func TestAddInstanceToRule(t *testing.T) {
 		t.Fatalf("got an unexpected error: %v", err)
 	}
 
+	ctx := context.TODO()
+
 	testCases := []struct {
 		name              string
 		eventBridgeExpect func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder)
@@ -257,7 +279,7 @@ func TestAddInstanceToRule(t *testing.T) {
 		{
 			name: "adds instance to event pattern when it doesn't exist",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.DescribeRule(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 					Name: aws.String("test-cluster-ec2-rule"),
 				}).Return(&eventbridge.DescribeRuleOutput{
 					EventPattern: aws.String(string(patternData)),
@@ -268,10 +290,10 @@ func TestAddInstanceToRule(t *testing.T) {
 				if err != nil {
 					t.Fatalf("got an unexpected error: %v", err)
 				}
-				m.PutRule(&eventbridge.PutRuleInput{
+				m.PutRule(ctx, &eventbridge.PutRuleInput{
 					Name:         aws.String("test-cluster-ec2-rule"),
 					EventPattern: aws.String(string(expectedData)),
-					State:        aws.String(eventbridge.RuleStateEnabled),
+					State:        eventbridgetypes.RuleStateEnabled,
 				}).Return(nil, nil)
 			},
 			newInstanceID: "instance-b",
@@ -280,7 +302,7 @@ func TestAddInstanceToRule(t *testing.T) {
 		{
 			name: "does nothing if instance is already tracked in event pattern",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.DescribeRule(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 					Name: aws.String("test-cluster-ec2-rule"),
 				}).Return(&eventbridge.DescribeRuleOutput{
 					EventPattern: aws.String(string(patternData)),
@@ -302,7 +324,7 @@ func TestAddInstanceToRule(t *testing.T) {
 			s := NewService(clusterScope)
 			s.EventBridgeClient = eventbridgeMock
 
-			err = s.AddInstanceToEventPattern(tc.newInstanceID)
+			err = s.AddInstanceToEventPattern(ctx, tc.newInstanceID)
 			if tc.expectErr {
 				g.Expect(err).NotTo(BeNil())
 			} else {
@@ -327,6 +349,8 @@ func TestRemoveInstanceStateFromEventPattern(t *testing.T) {
 		t.Fatalf("got an unexpected error: %v", err)
 	}
 
+	ctx := context.TODO()
+
 	testCases := []struct {
 		name              string
 		eventBridgeExpect func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder)
@@ -341,7 +365,7 @@ func TestRemoveInstanceStateFromEventPattern(t *testing.T) {
 				if err != nil {
 					t.Fatalf("got an unexpected error: %v", err)
 				}
-				m.DescribeRule(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 					Name: aws.String("test-cluster-ec2-rule"),
 				}).Return(&eventbridge.DescribeRuleOutput{
 					EventPattern: aws.String(string(patternData)),
@@ -353,10 +377,10 @@ func TestRemoveInstanceStateFromEventPattern(t *testing.T) {
 					t.Fatalf("got an unexpected error: %v", err)
 				}
 
-				m.PutRule(&eventbridge.PutRuleInput{
+				m.PutRule(ctx, &eventbridge.PutRuleInput{
 					Name:         aws.String("test-cluster-ec2-rule"),
 					EventPattern: aws.String(string(expectedData)),
-					State:        aws.String(eventbridge.RuleStateDisabled),
+					State:        eventbridgetypes.RuleStateDisabled,
 				}).Return(nil, nil)
 			},
 			instanceID: "instance-a",
@@ -364,7 +388,7 @@ func TestRemoveInstanceStateFromEventPattern(t *testing.T) {
 		{
 			name: "remove instance from instance IDs and rule remains enabled when other instances are tracked",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.DescribeRule(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 					Name: aws.String("test-cluster-ec2-rule"),
 				}).Return(&eventbridge.DescribeRuleOutput{
 					EventPattern: aws.String(string(patternData)),
@@ -375,10 +399,10 @@ func TestRemoveInstanceStateFromEventPattern(t *testing.T) {
 				if err != nil {
 					t.Fatalf("got an unexpected error: %v", err)
 				}
-				m.PutRule(&eventbridge.PutRuleInput{
+				m.PutRule(ctx, &eventbridge.PutRuleInput{
 					Name:         aws.String("test-cluster-ec2-rule"),
 					EventPattern: aws.String(string(expectedData)),
-					State:        aws.String(eventbridge.RuleStateEnabled),
+					State:        eventbridgetypes.RuleStateEnabled,
 				}).Return(nil, nil)
 			},
 			instanceID: "instance-b",
@@ -386,7 +410,7 @@ func TestRemoveInstanceStateFromEventPattern(t *testing.T) {
 		{
 			name: "does nothing when instanceID is not tracked",
 			eventBridgeExpect: func(m *mock_eventbridgeiface.MockEventBridgeAPIMockRecorder) {
-				m.DescribeRule(&eventbridge.DescribeRuleInput{
+				m.DescribeRule(ctx, &eventbridge.DescribeRuleInput{
 					Name: aws.String("test-cluster-ec2-rule"),
 				}).Return(&eventbridge.DescribeRuleOutput{
 					EventPattern: aws.String(string(patternData)),
@@ -407,7 +431,7 @@ func TestRemoveInstanceStateFromEventPattern(t *testing.T) {
 			s := NewService(clusterScope)
 			s.EventBridgeClient = eventbridgeMock
 
-			s.RemoveInstanceFromEventPattern(tc.instanceID)
+			s.RemoveInstanceFromEventPattern(ctx, tc.instanceID)
 		})
 	}
 }