diff --git a/go.mod b/go.mod index 33224dc283..72fbc46344 100644 --- a/go.mod +++ b/go.mod @@ -10,19 +10,19 @@ require ( github.com/aws/aws-sdk-go-v2 v1.40.0 github.com/aws/aws-sdk-go-v2/config v1.31.12 github.com/aws/aws-sdk-go-v2/credentials v1.18.21 - github.com/aws/aws-sdk-go-v2/service/autoscaling v1.60.4 - github.com/aws/aws-sdk-go-v2/service/cloudformation v1.68.4 - github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.53.12 - github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.58.8 + github.com/aws/aws-sdk-go-v2/service/autoscaling v1.62.0 + github.com/aws/aws-sdk-go-v2/service/cloudformation v1.71.0 + github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.55.0 + github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.60.1 github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider v1.57.7 - github.com/aws/aws-sdk-go-v2/service/ec2 v1.267.0 + github.com/aws/aws-sdk-go-v2/service/ec2 v1.274.0 github.com/aws/aws-sdk-go-v2/service/eks v1.75.0 - github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.33.12 - github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.51.6 - github.com/aws/aws-sdk-go-v2/service/iam v1.50.1 + github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.33.14 + github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.54.1 + github.com/aws/aws-sdk-go-v2/service/iam v1.52.1 github.com/aws/aws-sdk-go-v2/service/kms v1.47.1 - github.com/aws/aws-sdk-go-v2/service/outposts v1.57.6 - github.com/aws/aws-sdk-go-v2/service/ssm v1.67.1 + github.com/aws/aws-sdk-go-v2/service/outposts v1.57.7 + github.com/aws/aws-sdk-go-v2/service/ssm v1.67.3 github.com/aws/aws-sdk-go-v2/service/sts v1.39.1 github.com/aws/smithy-go v1.23.2 github.com/awslabs/amazon-eks-ami/nodeadm v0.0.0-20251001043626-89ce6578d960 @@ -142,7 +142,7 @@ require ( github.com/aws/aws-sdk-go-v2/service/eventbridge v1.39.3 // indirect github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.3 // indirect github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.4 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.13 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.14 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.17 // indirect github.com/aws/aws-sdk-go-v2/service/pricing v1.34.3 // indirect github.com/aws/aws-sdk-go-v2/service/route53 v1.52.2 // indirect diff --git a/go.sum b/go.sum index 379386867d..d9a3fc59f8 100644 --- a/go.sum +++ b/go.sum @@ -128,38 +128,58 @@ github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.36 h1:GMYy2EOWfzdP3wfVAGXBNKY5vK4 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.60.4 h1:XPL2qn+TNRPS0CsGB/pKvJA1HHAfEn16o6GXZMJbvIA= github.com/aws/aws-sdk-go-v2/service/autoscaling v1.60.4/go.mod h1:6E1AiecbY52kVBl8lKkdaO759rbGK3TBBBNnfxJezTM= +github.com/aws/aws-sdk-go-v2/service/autoscaling v1.62.0 h1:cYsffsQcIls7mqvMQ3+SkaUXgz/CvxBQgJFrKCLj64k= +github.com/aws/aws-sdk-go-v2/service/autoscaling v1.62.0/go.mod h1:6q/I1pH386VpPfB6FE62X/MOs6NW/oCsY9FXU33YXOU= github.com/aws/aws-sdk-go-v2/service/cloudformation v1.68.4 h1:D57iQSepmFzw6skoBuNT3eoKKpkhDH+ME8JDRgMoTZE= github.com/aws/aws-sdk-go-v2/service/cloudformation v1.68.4/go.mod h1:llucikq1Q6I1Ps8rNV3St0bOY5RQMxYh1lpCaskyhPw= +github.com/aws/aws-sdk-go-v2/service/cloudformation v1.71.0 h1:waVr7mqef4+goGzqrodFZmQp/QI6p31wBHHFXV5FZtI= +github.com/aws/aws-sdk-go-v2/service/cloudformation v1.71.0/go.mod h1:AIfiLeQfCO8suB3zxZp155Sv9KfiDhPyF+SSIRLEUYk= github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.53.12 h1:dk9p9exptlAdLIGzirB0kV1wq9G7Y/V2I9u6bN8A4sI= github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.53.12/go.mod h1:yPef5Em35Sb/89IIHAOarpsld8EuxyxuDVDlHj32LVA= +github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.55.0 h1:6Sv/xMZqb4koEQQYF3OsqBc+v5+oTFCGOepEhKReyhs= +github.com/aws/aws-sdk-go-v2/service/cloudtrail v1.55.0/go.mod h1:XSNDmicqamWtX6yg5lisFAiFaf56PErQo/cMQvUQWX0= github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.58.8 h1:mFNod70XE9Q8ex+G74R/baYan5s/++WJBBgB10aK1oE= github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.58.8/go.mod h1:9/Q0/HtqBTLMksFse42wZjUq0jJrUuo4XlnXy/uSoeg= +github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.60.1 h1:ZVEs9ZPzCsX9n1/Pr+x+ms1f6UZOPjuj9evCmwHceA4= +github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.60.1/go.mod h1:WXcA3mYRgWVIzjD+kxzap0axltmt4zBVDZaRX0S86gk= github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider v1.57.7 h1:1LPBlVrceFenrbWOZBGu8KTmX8TTMpZfRxX0HCnSjz0= github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider v1.57.7/go.mod h1:l8KDrD4EZQwTuM69YK3LFZ4c9VbNHrzaQJjJsoIFqfo= github.com/aws/aws-sdk-go-v2/service/ec2 v1.267.0 h1:WDY9IcD4z/ZCQP6YkZoTX/ck7mDGly88EmQV4VKidK4= github.com/aws/aws-sdk-go-v2/service/ec2 v1.267.0/go.mod h1:NDdDLLW5PtLLXN661gKcvJvqAH5OBXsfhMlmKVu1/pY= +github.com/aws/aws-sdk-go-v2/service/ec2 v1.274.0 h1:Q2+WD4KSVRkd27QxD9I30nM3O7B4WYwE+ua5dm2NJY0= +github.com/aws/aws-sdk-go-v2/service/ec2 v1.274.0/go.mod h1:QrV+/GjhSrJh6MRRuTO6ZEg4M2I0nwPakf0lZHSrE1o= github.com/aws/aws-sdk-go-v2/service/eks v1.75.0 h1:89rFFYB+HtoW6no7MrEK9dYydrY7ojpyjMROyHPrlSk= github.com/aws/aws-sdk-go-v2/service/eks v1.75.0/go.mod h1:lrJRZkSj6nIXH/SN3gbGQp4i4AtNyha0wT7VgYZ3KDw= github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.33.12 h1:967bczaPI2Hvw/JbrhgYGs8i6zvseiR/LJ8+LSDrdLU= github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.33.12/go.mod h1:ImGbJ8W4fb8KZekLSWCnuuabYN5WusCD7cnW4Nz7i14= +github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.33.14 h1:MRXEhiJNnnNOck/FEaO0msVXJscCDUfNTuYe5RGgf/E= +github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing v1.33.14/go.mod h1:QEbuU4eh8HGdv4uvld0Jth+KW8L0lOSYlyPcW6+JJo8= github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.51.6 h1:4LKLhbDyzhqWXDxWD86bNvVYCSUVbY3PipJ3uF7CdJk= github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.51.6/go.mod h1:Uyo8wjqYyZaHVqoe+APHe4+THRGv4pctJzItYYnRe5Q= +github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.54.1 h1:SVvYK137B8mS8W6c4rbu/eh3PGdz6ZOEIU/rHeUCRYM= +github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.54.1/go.mod h1:DpGMmFhQwV/HH9zugLT5Ovf9HMKdQ+6ejfJybqEC9i4= 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.50.1 h1:/IkrDJIaAvHo3D0BkkIot/EXg8ta+gSuWqNJ+EsFcdk= github.com/aws/aws-sdk-go-v2/service/iam v1.50.1/go.mod h1:cuEMbL1mNtO1sUyT+DYDNIA8Y7aJG1oIdgHqUk29Uzk= +github.com/aws/aws-sdk-go-v2/service/iam v1.52.1 h1:OYigTuTHayk1j11osOuJqIEuXSGAVndZYKH4aZYn8qk= +github.com/aws/aws-sdk-go-v2/service/iam v1.52.1/go.mod h1:PuHz5kGh1jtsNpjezdYhRp7xgn6DzCNJJfQt7O7U9Aw= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.3 h1:x2Ibm/Af8Fi+BH+Hsn9TXGdT+hKbDd5XOTZxTMxDk7o= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.3/go.mod h1:IW1jwyrQgMdhisceG8fQLmQIydcT/jWY21rFhzgaKwo= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.4 h1:nAP2GYbfh8dd2zGZqFRSMlq+/F6cMPBUuCsGAMkN074= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.4/go.mod h1:LT10DsiGjLWh4GbjInf9LQejkYEhBgBCjLG5+lvk4EE= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.13 h1:kDqdFvMY4AtKoACfzIGD8A0+hbT41KTKF//gq7jITfM= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.13/go.mod h1:lmKuogqSU3HzQCwZ9ZtcqOc5XGMqtDK7OIc2+DxiUEg= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.14 h1:FIouAnCE46kyYqyhs0XEBDFFSREtdnr8HQuLPQPLCrY= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.14/go.mod h1:UTwDc5COa5+guonQU8qBikJo1ZJ4ln2r1MkF7Dqag1E= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.17 h1:qcLWgdhq45sDM9na4cvXax9dyLitn8EYBRl8Ak4XtG4= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.17/go.mod h1:M+jkjBFZ2J6DJrjMv2+vkBbuht6kxJYtJiwoVgX4p4U= github.com/aws/aws-sdk-go-v2/service/kms v1.47.1 h1:6+C0RoGF4HJQALrsecOXN7cm/l5rgNHCw2xbcvFgpH4= github.com/aws/aws-sdk-go-v2/service/kms v1.47.1/go.mod h1:VJcNH6BLr+3VJwinRKdotLOMglHO8mIKlD3ea5c7hbw= github.com/aws/aws-sdk-go-v2/service/outposts v1.57.6 h1:FXA9OzvJlakCrbvKw3qmLrRG6q3EDt9FZnaS4Tx3upQ= github.com/aws/aws-sdk-go-v2/service/outposts v1.57.6/go.mod h1:rPsJtWQtj/V1kgdAFC9WyswmqrvJaOgHfLwibijL52o= +github.com/aws/aws-sdk-go-v2/service/outposts v1.57.7 h1:bCFa84n5+eYIrKPkA0RGjnW4HzOVlYxK7/x3Ve2mAQk= +github.com/aws/aws-sdk-go-v2/service/outposts v1.57.7/go.mod h1:3osURGv9q/2wxP1qYnB15GWYgr6w2AbQkSxYtE6vTaY= github.com/aws/aws-sdk-go-v2/service/pricing v1.34.3 h1:vAv0hi3SWcc8cotkWRP4mPkmRbp/XqWKFyPW4Nwpzv0= github.com/aws/aws-sdk-go-v2/service/pricing v1.34.3/go.mod h1:giTP9ufzBQJRB6bc7P30PO8s35hCp6au5uM70zkohU4= github.com/aws/aws-sdk-go-v2/service/route53 v1.52.2 h1:dXHWVVPx2W2fq2PTugj8QXpJ0YTRAGx0KLPKhMBmcsY= @@ -170,6 +190,8 @@ github.com/aws/aws-sdk-go-v2/service/sqs v1.38.8 h1:80dpSqWMwx2dAm30Ib7J6ucz1ZHf 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/ssm v1.67.1 h1:Zl+dJQSS5RogzWXBdS3eo5aVeHm/se5BGR1JrcIU+pA= github.com/aws/aws-sdk-go-v2/service/ssm v1.67.1/go.mod h1:uNHuYAQazkHqpD+hVomA2+eDSuKJzerno7Fnha6N6/Y= +github.com/aws/aws-sdk-go-v2/service/ssm v1.67.3 h1:ofiQvKwka2E3T8FXBsU1iWj7Yvk2wd1p4ZCdS6qGiKQ= +github.com/aws/aws-sdk-go-v2/service/ssm v1.67.3/go.mod h1:+nlWvcgDPQ56mChEBzTC0puAMck+4onOFaHg5cE+Lgg= github.com/aws/aws-sdk-go-v2/service/sso v1.30.1 h1:0JPwLz1J+5lEOfy/g0SURC9cxhbQ1lIMHMa+AHZSzz0= github.com/aws/aws-sdk-go-v2/service/sso v1.30.1/go.mod h1:fKvyjJcz63iL/ftA6RaM8sRCtN4r4zl4tjL3qw5ec7k= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.5 h1:OWs0/j2UYR5LOGi88sD5/lhN6TDLG6SfA7CqsQO9zF0= diff --git a/pkg/apis/eksctl.io/v1alpha5/outposts_validation_test.go b/pkg/apis/eksctl.io/v1alpha5/outposts_validation_test.go index 86e62dd056..ddb3ca2df8 100644 --- a/pkg/apis/eksctl.io/v1alpha5/outposts_validation_test.go +++ b/pkg/apis/eksctl.io/v1alpha5/outposts_validation_test.go @@ -199,12 +199,13 @@ var _ = Describe("Outposts validation", func() { }, }, clusterConfig) if shouldFail { - Expect(err).To(MatchError("only AmazonLinux2 is supported on local clusters")) + Expect(err).To(MatchError("only AmazonLinux2023 is supported on local clusters")) } else { Expect(err).NotTo(HaveOccurred()) } }, - Entry("AmazonLinux2", api.NodeImageFamilyAmazonLinux2, false), + Entry("AmazonLinux2", api.NodeImageFamilyAmazonLinux2, true), + Entry("AmazonLinux2023", api.NodeImageFamilyAmazonLinux2023, false), Entry("Bottlerocket", api.NodeImageFamilyBottlerocket, true), Entry("Ubuntu2004", api.NodeImageFamilyUbuntu2004, true), Entry("UbuntuPro2004", api.NodeImageFamilyUbuntuPro2004, true), diff --git a/pkg/apis/eksctl.io/v1alpha5/validation.go b/pkg/apis/eksctl.io/v1alpha5/validation.go index d508c90a24..3127bed159 100644 --- a/pkg/apis/eksctl.io/v1alpha5/validation.go +++ b/pkg/apis/eksctl.io/v1alpha5/validation.go @@ -757,8 +757,8 @@ func validateNodeGroupBase(np NodePool, path string, controlPlaneOnOutposts bool } return fmt.Errorf("AMI Family %s is not supported - use one of: %s", ng.AMIFamily, strings.Join(SupportedAMIFamilies(), ", ")) } - if controlPlaneOnOutposts && ng.AMIFamily != NodeImageFamilyAmazonLinux2 { - return fmt.Errorf("only %s is supported on local clusters", NodeImageFamilyAmazonLinux2) + if controlPlaneOnOutposts && ng.AMIFamily != NodeImageFamilyAmazonLinux2023 { + return fmt.Errorf("only %s is supported on local clusters", NodeImageFamilyAmazonLinux2023) } } diff --git a/pkg/apis/eksctl.io/v1alpha5/zz_generated.deepcopy.go b/pkg/apis/eksctl.io/v1alpha5/zz_generated.deepcopy.go index 56df91fecd..6b2f51a56c 100644 --- a/pkg/apis/eksctl.io/v1alpha5/zz_generated.deepcopy.go +++ b/pkg/apis/eksctl.io/v1alpha5/zz_generated.deepcopy.go @@ -1,4 +1,5 @@ //go:build !ignore_autogenerated +// +build !ignore_autogenerated /* Copyright 2018 Weaveworks. @@ -553,6 +554,11 @@ func (in *ClusterConfig) DeepCopyInto(out *ClusterConfig) { *out = new(Outpost) (*in).DeepCopyInto(*out) } + if in.ControlPlaneScalingConfig != nil { + in, out := &in.ControlPlaneScalingConfig, &out.ControlPlaneScalingConfig + *out = new(ControlPlaneScalingConfig) + (*in).DeepCopyInto(*out) + } if in.ZonalShiftConfig != nil { in, out := &in.ZonalShiftConfig, &out.ZonalShiftConfig *out = new(ZonalShiftConfig) @@ -995,6 +1001,27 @@ func (in *ClusterVPC) DeepCopy() *ClusterVPC { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ControlPlaneScalingConfig) DeepCopyInto(out *ControlPlaneScalingConfig) { + *out = *in + if in.Tier != nil { + in, out := &in.Tier, &out.Tier + *out = new(string) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ControlPlaneScalingConfig. +func (in *ControlPlaneScalingConfig) DeepCopy() *ControlPlaneScalingConfig { + if in == nil { + return nil + } + out := new(ControlPlaneScalingConfig) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in CustomStringSlice) DeepCopyInto(out *CustomStringSlice) { { diff --git a/pkg/awsapi/autoscaling.go b/pkg/awsapi/autoscaling.go index d53ad66f5f..5c5bcae79a 100644 --- a/pkg/awsapi/autoscaling.go +++ b/pkg/awsapi/autoscaling.go @@ -606,6 +606,11 @@ type ASG interface { // // [Predictive scaling for Amazon EC2 Auto Scaling]: https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-predictive-scaling.html GetPredictiveScalingForecast(ctx context.Context, params *autoscaling.GetPredictiveScalingForecastInput, optFns ...func(*Options)) (*autoscaling.GetPredictiveScalingForecastOutput, error) + // Launches a specified number of instances in an Auto Scaling group. Returns + // + // instance IDs and other details if launch is successful or error details if + // launch is unsuccessful. + LaunchInstances(ctx context.Context, params *autoscaling.LaunchInstancesInput, optFns ...func(*Options)) (*autoscaling.LaunchInstancesOutput, error) // Creates or updates a lifecycle hook for the specified Auto Scaling group. // // Lifecycle hooks let you create solutions that are aware of events in the Auto diff --git a/pkg/awsapi/cloudformation.go b/pkg/awsapi/cloudformation.go index ed862b40cc..e07dcaae54 100644 --- a/pkg/awsapi/cloudformation.go +++ b/pkg/awsapi/cloudformation.go @@ -226,9 +226,32 @@ type CloudFormation interface { // // [Update CloudFormation stacks using change sets]: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html DescribeChangeSet(ctx context.Context, params *cloudformation.DescribeChangeSetInput, optFns ...func(*Options)) (*cloudformation.DescribeChangeSetOutput, error) - // Returns hook-related information for the change set and a list of changes that + // Returns Hook-related information for the change set and a list of changes that // CloudFormation makes when you run the change set. DescribeChangeSetHooks(ctx context.Context, params *cloudformation.DescribeChangeSetHooksInput, optFns ...func(*Options)) (*cloudformation.DescribeChangeSetHooksOutput, error) + // Returns CloudFormation events based on flexible query criteria. Groups events + // by operation ID, enabling you to focus on individual stack operations during + // deployment. + // + // An operation is any action performed on a stack, including stack lifecycle + // actions (Create, Update, Delete, Rollback), change set creation, nested stack + // creation, and automatic rollbacks triggered by failures. Each operation has a + // unique identifier (Operation ID) and represents a discrete change attempt on the + // stack. + // + // Returns different types of events including: + // + // - Progress events - Status updates during stack operation execution. + // + // - Validation errors - Failures from CloudFormation Early Validations. + // + // - Provisioning errors - Resource creation and update failures. + // + // - Hook invocation errors - Failures from CloudFormation Hook during stack + // operations. + // + // One of ChangeSetName , OperationId or StackName must be specified as input. + DescribeEvents(ctx context.Context, params *cloudformation.DescribeEventsInput, optFns ...func(*Options)) (*cloudformation.DescribeEventsOutput, error) // Describes a generated template. The output includes details about the progress // of the creation of a generated template started by a CreateGeneratedTemplate // API action or the update of a generated template started with an @@ -466,6 +489,15 @@ type CloudFormation interface { // last in a Complete status. If the template has not yet been in a Complete // status then an empty template will be returned. GetGeneratedTemplate(ctx context.Context, params *cloudformation.GetGeneratedTemplateInput, optFns ...func(*Options)) (*cloudformation.GetGeneratedTemplateOutput, error) + // Retrieves detailed information and remediation guidance for a Hook invocation + // result. + // + // If the Hook uses a KMS key to encrypt annotations, callers of the GetHookResult + // operation must have kms:Decrypt permissions. For more information, see [KMS key policy and permissions for encrypting CloudFormation Hooks results at rest] in the + // CloudFormation Hooks User Guide. + // + // [KMS key policy and permissions for encrypting CloudFormation Hooks results at rest]: https://docs.aws.amazon.com/cloudformation-cli/latest/hooks-userguide/hooks-kms-key-policy.html + GetHookResult(ctx context.Context, params *cloudformation.GetHookResultInput, optFns ...func(*Options)) (*cloudformation.GetHookResultOutput, error) // Returns the stack policy for a specified stack. If a stack doesn't have a // policy, a null value is returned. GetStackPolicy(ctx context.Context, params *cloudformation.GetStackPolicyInput, optFns ...func(*Options)) (*cloudformation.GetStackPolicyOutput, error) diff --git a/pkg/awsapi/cloudtrail.go b/pkg/awsapi/cloudtrail.go index aa0831610b..3ffa122b88 100644 --- a/pkg/awsapi/cloudtrail.go +++ b/pkg/awsapi/cloudtrail.go @@ -97,6 +97,19 @@ type CloudTrail interface { // Deletes a trail. This operation must be called from the Region in which the // trail was created. DeleteTrail cannot be called on the shadow trails // (replicated trails in other Regions) of a trail that is enabled in all Regions. + // + // While deleting a CloudTrail trail is an irreversible action, CloudTrail does + // not delete log files in the Amazon S3 bucket for that trail, the Amazon S3 + // bucket itself, or the CloudWatchlog group to which the trail delivers events. + // Deleting a multi-Region trail will stop logging of events in all Amazon Web + // Services Regions enabled in your Amazon Web Services account. Deleting a + // single-Region trail will stop logging of events in that Region only. It will not + // stop logging of events in other Regions even if the trails in those other + // Regions have identical names to the deleted trail. + // + // For information about account closure and deletion of CloudTrail trails, see [https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-account-closure.html]. + // + // [https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-account-closure.html]: https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-account-closure.html DeleteTrail(ctx context.Context, params *cloudtrail.DeleteTrailInput, optFns ...func(*Options)) (*cloudtrail.DeleteTrailOutput, error) // Removes CloudTrail delegated administrator permissions from a member account in // an organization. @@ -168,8 +181,9 @@ type CloudTrail interface { // Returns the specified dashboard. GetDashboard(ctx context.Context, params *cloudtrail.GetDashboardInput, optFns ...func(*Options)) (*cloudtrail.GetDashboardOutput, error) // Retrieves the current event configuration settings for the specified event data - // store, including details about maximum event size and context key selectors - // configured for the event data store. + // store or trail. The response includes maximum event size configuration, the + // context key selectors configured for the event data store, and any aggregation + // settings configured for the trail. GetEventConfiguration(ctx context.Context, params *cloudtrail.GetEventConfigurationInput, optFns ...func(*Options)) (*cloudtrail.GetEventConfigurationOutput, error) // Returns information about an event data store specified as either an ARN or the // ID portion of the ARN. @@ -206,9 +220,9 @@ type CloudTrail interface { GetImport(ctx context.Context, params *cloudtrail.GetImportInput, optFns ...func(*Options)) (*cloudtrail.GetImportOutput, error) // Describes the settings for the Insights event selectors that you configured for // your trail or event data store. GetInsightSelectors shows if CloudTrail - // Insights event logging is enabled on the trail or event data store, and if it - // is, which Insights types are enabled. If you run GetInsightSelectors on a trail - // or event data store that does not have Insights events enabled, the operation + // Insights logging is enabled and which Insights types are configured with + // corresponding event categories. If you run GetInsightSelectors on a trail or + // event data store that does not have Insights events enabled, the operation // throws the exception InsightNotEnabledException // // Specify either the EventDataStore parameter to get Insights event selectors for @@ -249,6 +263,24 @@ type CloudTrail interface { // // or Destination . ListImports(ctx context.Context, params *cloudtrail.ListImportsInput, optFns ...func(*Options)) (*cloudtrail.ListImportsOutput, error) + // Returns Insights events generated on a trail that logs data events. You can + // list Insights events that occurred in a Region within the last 90 days. + // + // ListInsightsData supports the following Dimensions for Insights events: + // + // - Event ID + // + // - Event name + // + // - Event source + // + // All dimensions are optional. The default number of results returned is 50, with + // a maximum of 50 possible. The response includes a token that you can use to get + // the next page of results. + // + // The rate of ListInsightsData requests is limited to two per second, per + // account, per Region. If this limit is exceeded, a throttling error occurs. + ListInsightsData(ctx context.Context, params *cloudtrail.ListInsightsDataInput, optFns ...func(*Options)) (*cloudtrail.ListInsightsDataOutput, error) // Returns Insights metrics data for trails that have enabled Insights. The // request must include the EventSource , EventName , and InsightType parameters. // @@ -267,9 +299,19 @@ type CloudTrail interface { // - Data points with a period of 3600 seconds (1 hour) are available for 90 // days. // - // Access to the ListInsightsMetricData API operation is linked to the - // cloudtrail:LookupEvents action. To use this operation, you must have permissions - // to perform the cloudtrail:LookupEvents action. + // To use ListInsightsMetricData operation, you must have the following + // permissions: + // + // - If ListInsightsMetricData is invoked with TrailName parameter, access to the + // ListInsightsMetricData API operation is linked to the cloudtrail:LookupEvents + // action and cloudtrail:ListInsightsData . To use this operation, you must have + // permissions to perform the cloudtrail:LookupEvents and + // cloudtrail:ListInsightsData action on the specific trail. + // + // - If ListInsightsMetricData is invoked without TrailName parameter, access to + // the ListInsightsMetricData API operation is linked to the + // cloudtrail:LookupEvents action only. To use this operation, you must have + // permissions to perform the cloudtrail:LookupEvents action. ListInsightsMetricData(ctx context.Context, params *cloudtrail.ListInsightsMetricDataInput, optFns ...func(*Options)) (*cloudtrail.ListInsightsMetricDataOutput, error) // Returns all public keys whose private keys were used to sign the digest files // within the specified time range. The public key is needed to validate digest @@ -336,8 +378,10 @@ type CloudTrail interface { // [CloudTrail Insights events]: https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-concepts.html#cloudtrail-concepts-insights-events // [management events]: https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-concepts.html#cloudtrail-concepts-management-events LookupEvents(ctx context.Context, params *cloudtrail.LookupEventsInput, optFns ...func(*Options)) (*cloudtrail.LookupEventsOutput, error) - // Updates the event configuration settings for the specified event data store. - // You can update the maximum event size and context key selectors. + // Updates the event configuration settings for the specified event data store or + // trail. This operation supports updating the maximum event size, adding or + // modifying context key selectors for event data store, and configuring + // aggregation settings for the trail. PutEventConfiguration(ctx context.Context, params *cloudtrail.PutEventConfigurationInput, optFns ...func(*Options)) (*cloudtrail.PutEventConfigurationOutput, error) // Configures event selectors (also referred to as basic event selectors) or // advanced event selectors for your trail. You can use either @@ -401,11 +445,15 @@ type CloudTrail interface { // [Quotas in CloudTrail]: https://docs.aws.amazon.com/awscloudtrail/latest/userguide/WhatIsCloudTrail-Limits.html // [Logging data events]: https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html PutEventSelectors(ctx context.Context, params *cloudtrail.PutEventSelectorsInput, optFns ...func(*Options)) (*cloudtrail.PutEventSelectorsOutput, error) - // Lets you enable Insights event logging by specifying the Insights selectors - // that you want to enable on an existing trail or event data store. You also use - // PutInsightSelectors to turn off Insights event logging, by passing an empty list - // of Insights types. The valid Insights event types are ApiErrorRateInsight and - // ApiCallRateInsight . + // Lets you enable Insights event logging on specific event categories by + // specifying the Insights selectors that you want to enable on an existing trail + // or event data store. You also use PutInsightSelectors to turn off Insights + // event logging, by passing an empty list of Insights types. The valid Insights + // event types are ApiErrorRateInsight and ApiCallRateInsight , and valid + // EventCategories are Management and Data . + // + // Insights on data events are not supported on event data stores. For event data + // stores, you can only enable Insights on management events. // // To enable Insights on an event data store, you must specify the ARNs (or ID // suffix of the ARNs) for the source event data store ( EventDataStore ) and the @@ -418,6 +466,15 @@ type CloudTrail interface { // To log Insights events for a trail, you must specify the name ( TrailName ) of // the CloudTrail trail for which you want to change or add Insights selectors. // + // - For Management events Insights: To log CloudTrail Insights on the API call + // rate, the trail or event data store must log write management events. To log + // CloudTrail Insights on the API error rate, the trail or event data store must + // log read or write management events. + // + // - For Data events Insights: To log CloudTrail Insights on the API call rate + // or API error rate, the trail must log read or write data events. Data events + // Insights are not supported on event data store. + // // To log CloudTrail Insights events on API call volume, the trail or event data // store must log write management events. To log CloudTrail Insights events on // API error rate, the trail or event data store must log read or write management diff --git a/pkg/awsapi/cloudwatchlogs.go b/pkg/awsapi/cloudwatchlogs.go index 1bd1c03740..1a936f244a 100644 --- a/pkg/awsapi/cloudwatchlogs.go +++ b/pkg/awsapi/cloudwatchlogs.go @@ -231,6 +231,9 @@ type CloudWatchLogs interface { // // - Don't use ':' (colon) or '*' (asterisk) characters. CreateLogStream(ctx context.Context, params *cloudwatchlogs.CreateLogStreamInput, optFns ...func(*Options)) (*cloudwatchlogs.CreateLogStreamOutput, error) + // Creates a new Scheduled Query that runs CloudWatch Logs Insights queries on a + // schedule and delivers results to specified destinations. + CreateScheduledQuery(ctx context.Context, params *cloudwatchlogs.CreateScheduledQueryInput, optFns ...func(*Options)) (*cloudwatchlogs.CreateScheduledQueryOutput, error) // Deletes a CloudWatch Logs account policy. This stops the account-wide policy // from applying to log groups in the account. If you delete a data protection // policy or subscription filter policy, any log-group level policies of those @@ -341,6 +344,9 @@ type CloudWatchLogs interface { // Log events do not expire if they belong to log groups without a retention // policy. DeleteRetentionPolicy(ctx context.Context, params *cloudwatchlogs.DeleteRetentionPolicyInput, optFns ...func(*Options)) (*cloudwatchlogs.DeleteRetentionPolicyOutput, error) + // Deletes an existing scheduled query and all its associated configurations. This + // operation permanently removes the scheduled query and cannot be undone. + DeleteScheduledQuery(ctx context.Context, params *cloudwatchlogs.DeleteScheduledQueryInput, optFns ...func(*Options)) (*cloudwatchlogs.DeleteScheduledQueryOutput, error) // Deletes the specified subscription filter. DeleteSubscriptionFilter(ctx context.Context, params *cloudwatchlogs.DeleteSubscriptionFilterInput, optFns ...func(*Options)) (*cloudwatchlogs.DeleteSubscriptionFilterOutput, error) // Deletes the log transformer for the specified log group. As soon as you do @@ -680,6 +686,12 @@ type CloudWatchLogs interface { // [CloudWatch Logs quotas]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html // [StartQuery]: https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html GetQueryResults(ctx context.Context, params *cloudwatchlogs.GetQueryResultsInput, optFns ...func(*Options)) (*cloudwatchlogs.GetQueryResultsOutput, error) + // Returns detailed information about a specified scheduled query, including its + // configuration, current state, and execution history. + GetScheduledQuery(ctx context.Context, params *cloudwatchlogs.GetScheduledQueryInput, optFns ...func(*Options)) (*cloudwatchlogs.GetScheduledQueryOutput, error) + // Retrieves the execution history of a scheduled query within a specified time + // range, including execution status and destination processing metadata. + GetScheduledQueryHistory(ctx context.Context, params *cloudwatchlogs.GetScheduledQueryHistoryInput, optFns ...func(*Options)) (*cloudwatchlogs.GetScheduledQueryHistoryOutput, error) // Returns the information about the log transformer associated with this log // group. // @@ -722,6 +734,9 @@ type CloudWatchLogs interface { // // [Create field indexes to improve query performance and reduce costs]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatchLogs-Field-Indexing.html ListLogGroupsForQuery(ctx context.Context, params *cloudwatchlogs.ListLogGroupsForQueryInput, optFns ...func(*Options)) (*cloudwatchlogs.ListLogGroupsForQueryOutput, error) + // Lists all scheduled queries in the current AWS account and region with optional + // filtering by state. + ListScheduledQueries(ctx context.Context, params *cloudwatchlogs.ListScheduledQueriesInput, optFns ...func(*Options)) (*cloudwatchlogs.ListScheduledQueriesOutput, error) // Displays the tags associated with a CloudWatch Logs resource. Currently, log // groups and destinations support tagging. ListTagsForResource(ctx context.Context, params *cloudwatchlogs.ListTagsForResourceInput, optFns ...func(*Options)) (*cloudwatchlogs.ListTagsForResourceOutput, error) @@ -864,6 +879,8 @@ type CloudWatchLogs interface { // Standard log class. Default field indexes are automatically available for the // following fields: // + // - @logStream + // // - @aws.region // // - @aws.account @@ -1177,6 +1194,8 @@ type CloudWatchLogs interface { // Standard log class. Default field indexes are automatically available for the // following fields: // + // - @logStream + // // - @aws.region // // - @aws.account @@ -1316,8 +1335,23 @@ type CloudWatchLogs interface { // [Analyzing Log Data with CloudWatch Logs Insights]: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html PutQueryDefinition(ctx context.Context, params *cloudwatchlogs.PutQueryDefinitionInput, optFns ...func(*Options)) (*cloudwatchlogs.PutQueryDefinitionOutput, error) // Creates or updates a resource policy allowing other Amazon Web Services - // services to put log events to this account, such as Amazon Route 53. An account - // can have up to 10 resource policies per Amazon Web Services Region. + // services to put log events to this account, such as Amazon Route 53. This API + // has the following restrictions: + // + // - Supported actions - Policy only supports logs:PutLogEvents and + // logs:CreateLogStream actions + // + // - Supported principals - Policy only applies when operations are invoked by + // Amazon Web Services service principals (not IAM users, roles, or cross-account + // principals + // + // - Policy limits - An account can have a maximum of 10 policies without + // resourceARN and one per LogGroup resourceARN + // + // Resource policies with actions invoked by non-Amazon Web Services service + // principals (such as IAM users, roles, or other Amazon Web Services accounts) + // will not be enforced. For access control involving these principals, use the IAM + // policies. PutResourcePolicy(ctx context.Context, params *cloudwatchlogs.PutResourcePolicyInput, optFns ...func(*Options)) (*cloudwatchlogs.PutResourcePolicyOutput, error) // Sets the retention of the specified log group. With a retention policy, you can // configure the number of days for which to retain log events in the specified log @@ -1608,5 +1642,9 @@ type CloudWatchLogs interface { UpdateDeliveryConfiguration(ctx context.Context, params *cloudwatchlogs.UpdateDeliveryConfigurationInput, optFns ...func(*Options)) (*cloudwatchlogs.UpdateDeliveryConfigurationOutput, error) // Updates an existing log anomaly detector. UpdateLogAnomalyDetector(ctx context.Context, params *cloudwatchlogs.UpdateLogAnomalyDetectorInput, optFns ...func(*Options)) (*cloudwatchlogs.UpdateLogAnomalyDetectorOutput, error) + // Updates the configuration of an existing scheduled query. This operation + // follows PUT semantics, replacing the existing configuration with the provided + // values. + UpdateScheduledQuery(ctx context.Context, params *cloudwatchlogs.UpdateScheduledQueryInput, optFns ...func(*Options)) (*cloudwatchlogs.UpdateScheduledQueryOutput, error) } diff --git a/pkg/awsapi/ec2.go b/pkg/awsapi/ec2.go index 1cdf368ebd..0be2ea7d3d 100644 --- a/pkg/awsapi/ec2.go +++ b/pkg/awsapi/ec2.go @@ -963,6 +963,12 @@ type EC2 interface { // // [Internet gateways]: https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html CreateInternetGateway(ctx context.Context, params *ec2.CreateInternetGatewayInput, optFns ...func(*Options)) (*ec2.CreateInternetGatewayOutput, error) + // Creates an interruptible Capacity Reservation by specifying the number of + // + // unused instances you want to allocate from your source reservation. This helps + // you make unused capacity available for other workloads within your account while + // maintaining control to reclaim it. + CreateInterruptibleCapacityReservationAllocation(ctx context.Context, params *ec2.CreateInterruptibleCapacityReservationAllocationInput, optFns ...func(*Options)) (*ec2.CreateInterruptibleCapacityReservationAllocationOutput, error) // Create an IPAM. Amazon VPC IP Address Manager (IPAM) is a VPC feature that you // can use to automate your IP address management workflows including assigning, // tracking, troubleshooting, and auditing IP addresses across Amazon Web Services @@ -979,6 +985,21 @@ type EC2 interface { // verification token to validate that you control a public IP address range when // you bring an IP address range to Amazon Web Services (BYOIP). CreateIpamExternalResourceVerificationToken(ctx context.Context, params *ec2.CreateIpamExternalResourceVerificationTokenInput, optFns ...func(*Options)) (*ec2.CreateIpamExternalResourceVerificationTokenOutput, error) + // Creates an IPAM policy. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + // + // For more information, see [Define public IPv4 allocation strategy with IPAM policies] in the Amazon VPC IPAM User Guide. + // + // [Define public IPv4 allocation strategy with IPAM policies]: https://docs.aws.amazon.com/vpc/latest/ipam/define-public-ipv4-allocation-strategy-with-ipam-policies.html + CreateIpamPolicy(ctx context.Context, params *ec2.CreateIpamPolicyInput, optFns ...func(*Options)) (*ec2.CreateIpamPolicyOutput, error) // Create an IP address pool for Amazon VPC IP Address Manager (IPAM). In IPAM, a // pool is a collection of contiguous IP addresses CIDRs. Pools enable you to // organize your IP addresses according to your routing and security needs. For @@ -1598,6 +1619,12 @@ type EC2 interface { // // [Connect peers]: https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html#tgw-connect-peer CreateTransitGatewayConnectPeer(ctx context.Context, params *ec2.CreateTransitGatewayConnectPeerInput, optFns ...func(*Options)) (*ec2.CreateTransitGatewayConnectPeerOutput, error) + // Creates a metering policy for a transit gateway to track and measure network + // traffic. + CreateTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyInput, optFns ...func(*Options)) (*ec2.CreateTransitGatewayMeteringPolicyOutput, error) + // Creates an entry in a transit gateway metering policy to define traffic + // measurement rules. + CreateTransitGatewayMeteringPolicyEntry(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyEntryInput, optFns ...func(*Options)) (*ec2.CreateTransitGatewayMeteringPolicyEntryOutput, error) // Creates a multicast domain using the specified transit gateway. // // The transit gateway must be in the available state before you create a domain. @@ -1702,6 +1729,15 @@ type EC2 interface { // // [Block public access to VPCs and subnets]: https://docs.aws.amazon.com/vpc/latest/userguide/security-vpc-bpa.html CreateVpcBlockPublicAccessExclusion(ctx context.Context, params *ec2.CreateVpcBlockPublicAccessExclusionInput, optFns ...func(*Options)) (*ec2.CreateVpcBlockPublicAccessExclusionOutput, error) + // Creates a VPC Encryption Control configuration for a specified VPC. VPC + // Encryption Control enables you to enforce encryption for all data in transit + // within and between VPCs to meet compliance requirements for standards like + // HIPAA, FedRAMP, and PCI DSS. + // + // For more information, see [Enforce VPC encryption in transit] in the Amazon VPC User Guide. + // + // [Enforce VPC encryption in transit]: https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html + CreateVpcEncryptionControl(ctx context.Context, params *ec2.CreateVpcEncryptionControlInput, optFns ...func(*Options)) (*ec2.CreateVpcEncryptionControlOutput, error) // Creates a VPC endpoint. A VPC endpoint provides a private connection between // the specified VPC and the specified endpoint service. You can use an endpoint // service provided by Amazon Web Services, an Amazon Web Services Marketplace @@ -1756,6 +1792,9 @@ type EC2 interface { // // [VPC peering limitations]: https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-basics.html#vpc-peering-limitations CreateVpcPeeringConnection(ctx context.Context, params *ec2.CreateVpcPeeringConnectionInput, optFns ...func(*Options)) (*ec2.CreateVpcPeeringConnectionOutput, error) + // Creates a VPN concentrator that aggregates multiple VPN connections to a + // transit gateway. + CreateVpnConcentrator(ctx context.Context, params *ec2.CreateVpnConcentratorInput, optFns ...func(*Options)) (*ec2.CreateVpnConcentratorOutput, error) // Creates a VPN connection between an existing virtual private gateway or transit // gateway and a customer gateway. The supported connection type is ipsec.1 . // @@ -1913,6 +1952,17 @@ type EC2 interface { // verification token to validate that you control a public IP address range when // you bring an IP address range to Amazon Web Services (BYOIP). DeleteIpamExternalResourceVerificationToken(ctx context.Context, params *ec2.DeleteIpamExternalResourceVerificationTokenInput, optFns ...func(*Options)) (*ec2.DeleteIpamExternalResourceVerificationTokenOutput, error) + // Deletes an IPAM policy. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + DeleteIpamPolicy(ctx context.Context, params *ec2.DeleteIpamPolicyInput, optFns ...func(*Options)) (*ec2.DeleteIpamPolicyOutput, error) // Delete an IPAM pool. // // You cannot delete an IPAM pool if there are allocations in it or CIDRs @@ -2132,6 +2182,10 @@ type EC2 interface { DeleteTransitGatewayConnect(ctx context.Context, params *ec2.DeleteTransitGatewayConnectInput, optFns ...func(*Options)) (*ec2.DeleteTransitGatewayConnectOutput, error) // Deletes the specified Connect peer. DeleteTransitGatewayConnectPeer(ctx context.Context, params *ec2.DeleteTransitGatewayConnectPeerInput, optFns ...func(*Options)) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) + // Deletes a transit gateway metering policy. + DeleteTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyInput, optFns ...func(*Options)) (*ec2.DeleteTransitGatewayMeteringPolicyOutput, error) + // Deletes an entry from a transit gateway metering policy. + DeleteTransitGatewayMeteringPolicyEntry(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, optFns ...func(*Options)) (*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, error) // Deletes the specified transit gateway multicast domain. DeleteTransitGatewayMulticastDomain(ctx context.Context, params *ec2.DeleteTransitGatewayMulticastDomainInput, optFns ...func(*Options)) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) // Deletes a transit gateway peering attachment. @@ -2189,6 +2243,13 @@ type EC2 interface { // // [Block public access to VPCs and subnets]: https://docs.aws.amazon.com/vpc/latest/userguide/security-vpc-bpa.html DeleteVpcBlockPublicAccessExclusion(ctx context.Context, params *ec2.DeleteVpcBlockPublicAccessExclusionInput, optFns ...func(*Options)) (*ec2.DeleteVpcBlockPublicAccessExclusionOutput, error) + // Deletes a VPC Encryption Control configuration. This removes the encryption + // policy enforcement from the specified VPC. + // + // For more information, see [Enforce VPC encryption in transit] in the Amazon VPC User Guide. + // + // [Enforce VPC encryption in transit]: https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html + DeleteVpcEncryptionControl(ctx context.Context, params *ec2.DeleteVpcEncryptionControlInput, optFns ...func(*Options)) (*ec2.DeleteVpcEncryptionControlOutput, error) // Deletes the specified VPC endpoint connection notifications. DeleteVpcEndpointConnectionNotifications(ctx context.Context, params *ec2.DeleteVpcEndpointConnectionNotificationsInput, optFns ...func(*Options)) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) // Deletes the specified VPC endpoint service configurations. Before you can @@ -2214,6 +2275,8 @@ type EC2 interface { // in the pending-acceptance state. You cannot delete a VPC peering connection // that's in the failed or rejected state. DeleteVpcPeeringConnection(ctx context.Context, params *ec2.DeleteVpcPeeringConnectionInput, optFns ...func(*Options)) (*ec2.DeleteVpcPeeringConnectionOutput, error) + // Deletes the specified VPN concentrator. + DeleteVpnConcentrator(ctx context.Context, params *ec2.DeleteVpnConcentratorInput, optFns ...func(*Options)) (*ec2.DeleteVpnConcentratorOutput, error) // Deletes the specified VPN connection. // // If you're deleting the VPC and its associated components, we recommend that you @@ -2698,7 +2761,8 @@ type EC2 interface { // Describes your import snapshot tasks. DescribeImportSnapshotTasks(ctx context.Context, params *ec2.DescribeImportSnapshotTasksInput, optFns ...func(*Options)) (*ec2.DescribeImportSnapshotTasksOutput, error) // Describes the specified attribute of the specified instance. You can specify - // only one attribute at a time. + // only one attribute at a time. Available attributes include SQL license exemption + // configuration for instances registered with the SQL LE service. DescribeInstanceAttribute(ctx context.Context, params *ec2.DescribeInstanceAttributeInput, optFns ...func(*Options)) (*ec2.DescribeInstanceAttributeOutput, error) // Describes the specified EC2 Instance Connect Endpoints or all EC2 Instance // Connect Endpoints. @@ -2772,6 +2836,13 @@ type EC2 interface { // structures, might vary. Applications should not assume the elements appear in a // particular order. DescribeInstanceImageMetadata(ctx context.Context, params *ec2.DescribeInstanceImageMetadataInput, optFns ...func(*Options)) (*ec2.DescribeInstanceImageMetadataOutput, error) + // Describes the historical SQL Server High Availability states for Amazon EC2 + // instances that are enabled for Amazon EC2 High Availability for SQL Server + // monitoring. + DescribeInstanceSqlHaHistoryStates(ctx context.Context, params *ec2.DescribeInstanceSqlHaHistoryStatesInput, optFns ...func(*Options)) (*ec2.DescribeInstanceSqlHaHistoryStatesOutput, error) + // Describes the SQL Server High Availability states for Amazon EC2 instances that + // are enabled for Amazon EC2 High Availability for SQL Server monitoring. + DescribeInstanceSqlHaStates(ctx context.Context, params *ec2.DescribeInstanceSqlHaStatesInput, optFns ...func(*Options)) (*ec2.DescribeInstanceSqlHaStatesOutput, error) // Describes the status of the specified instances or all of your instances. By // default, only running instances are described, unless you specifically indicate // to return the status of all instances. @@ -2790,6 +2861,10 @@ type EC2 interface { // them through their termination. For more information, see [Instance lifecycle]in the Amazon EC2 // User Guide. // + // - SQL license exemption monitoring - For instances registered with the SQL LE + // service, status includes SQL license exemption monitoring health and processing + // status to provide operational visibility into license exemption functionality. + // // The Amazon EC2 API follows an eventual consistency model. This means that the // result of an API command you run that creates or modifies resources might not be // immediately available to all subsequent commands you run. For guidance on how to @@ -2842,6 +2917,10 @@ type EC2 interface { // which can affect performance. We recommend that you use pagination to ensure // that the operation returns quickly and successfully. // + // The response includes SQL license exemption status information for instances + // registered with the SQL LE service, providing visibility into license exemption + // configuration and status. + // // If you specify an instance ID that is not valid, an error is returned. If you // specify an instance that you do not own, it is not included in the output. // @@ -2878,12 +2957,24 @@ type EC2 interface { // // [Tutorial: Bring your ASN to IPAM]: https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoasn.html DescribeIpamByoasn(ctx context.Context, params *ec2.DescribeIpamByoasnInput, optFns ...func(*Options)) (*ec2.DescribeIpamByoasnOutput, error) - // Describe verification tokens. A verification token is an Amazon Web - // Services-generated random value that you can use to prove ownership of an - // external resource. For example, you can use a verification token to validate - // that you control a public IP address range when you bring an IP address range to - // Amazon Web Services (BYOIP). + // Describe verification tokens. + // + // A verification token is an Amazon Web Services-generated random value that you + // can use to prove ownership of an external resource. For example, you can use a + // verification token to validate that you control a public IP address range when + // you bring an IP address range to Amazon Web Services (BYOIP). DescribeIpamExternalResourceVerificationTokens(ctx context.Context, params *ec2.DescribeIpamExternalResourceVerificationTokensInput, optFns ...func(*Options)) (*ec2.DescribeIpamExternalResourceVerificationTokensOutput, error) + // Describes one or more IPAM policies. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + DescribeIpamPolicies(ctx context.Context, params *ec2.DescribeIpamPoliciesInput, optFns ...func(*Options)) (*ec2.DescribeIpamPoliciesOutput, error) // Get information about your IPAM pools. DescribeIpamPools(ctx context.Context, params *ec2.DescribeIpamPoolsInput, optFns ...func(*Options)) (*ec2.DescribeIpamPoolsOutput, error) // Describes one or more IPAM prefix list resolver Targets. Use this operation to @@ -3392,6 +3483,8 @@ type EC2 interface { DescribeTransitGatewayConnectPeers(ctx context.Context, params *ec2.DescribeTransitGatewayConnectPeersInput, optFns ...func(*Options)) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) // Describes one or more Connect attachments. DescribeTransitGatewayConnects(ctx context.Context, params *ec2.DescribeTransitGatewayConnectsInput, optFns ...func(*Options)) (*ec2.DescribeTransitGatewayConnectsOutput, error) + // Describes one or more transit gateway metering policies. + DescribeTransitGatewayMeteringPolicies(ctx context.Context, params *ec2.DescribeTransitGatewayMeteringPoliciesInput, optFns ...func(*Options)) (*ec2.DescribeTransitGatewayMeteringPoliciesOutput, error) // Describes one or more transit gateway multicast domains. DescribeTransitGatewayMulticastDomains(ctx context.Context, params *ec2.DescribeTransitGatewayMulticastDomainsInput, optFns ...func(*Options)) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) // Describes your transit gateway peering attachments. @@ -3526,6 +3619,15 @@ type EC2 interface { // Similarly, the DNS hostname of an instance in a VPC resolves to its private IP // address when addressed from a linked EC2-Classic instance. DescribeVpcClassicLinkDnsSupport(ctx context.Context, params *ec2.DescribeVpcClassicLinkDnsSupportInput, optFns ...func(*Options)) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) + // Describes one or more VPC Encryption Control configurations. VPC Encryption + // Control enables you to enforce encryption for all data in transit within and + // between VPCs to meet compliance requirements You can filter the results to + // return information about specific encryption controls or VPCs. + // + // For more information, see [Enforce VPC encryption in transit] in the Amazon VPC User Guide. + // + // [Enforce VPC encryption in transit]: https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html + DescribeVpcEncryptionControls(ctx context.Context, params *ec2.DescribeVpcEncryptionControlsInput, optFns ...func(*Options)) (*ec2.DescribeVpcEncryptionControlsOutput, error) // Describes the VPC resources, VPC endpoint services, Amazon Lattice services, or // service networks associated with the VPC endpoint. DescribeVpcEndpointAssociations(ctx context.Context, params *ec2.DescribeVpcEndpointAssociationsInput, optFns ...func(*Options)) (*ec2.DescribeVpcEndpointAssociationsOutput, error) @@ -3563,6 +3665,8 @@ type EC2 interface { // you can specify specific VPC IDs or filter the results to include only the VPCs // that match specific criteria. DescribeVpcs(ctx context.Context, params *ec2.DescribeVpcsInput, optFns ...func(*Options)) (*ec2.DescribeVpcsOutput, error) + // Describes one or more of your VPN concentrators. + DescribeVpnConcentrators(ctx context.Context, params *ec2.DescribeVpnConcentratorsInput, optFns ...func(*Options)) (*ec2.DescribeVpnConcentratorsOutput, error) // Describes one or more of your VPN connections. // // For more information, see [Amazon Web Services Site-to-Site VPN] in the Amazon Web Services Site-to-Site VPN User @@ -3714,11 +3818,28 @@ type EC2 interface { // // [Protect an Amazon EC2 AMI from deregistration]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deregistration-protection.html DisableImageDeregistrationProtection(ctx context.Context, params *ec2.DisableImageDeregistrationProtectionInput, optFns ...func(*Options)) (*ec2.DisableImageDeregistrationProtectionOutput, error) + // Disable Amazon EC2 instances running in an SQL Server High Availability cluster + // from SQL Server High Availability instance standby detection monitoring. Once + // disabled, Amazon Web Services no longer monitors the metadata for the instances + // to determine whether they are active or standby nodes in the SQL Server High + // Availability cluster. + DisableInstanceSqlHaStandbyDetections(ctx context.Context, params *ec2.DisableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*Options)) (*ec2.DisableInstanceSqlHaStandbyDetectionsOutput, error) // Disable the IPAM account. For more information, see [Enable integration with Organizations] in the Amazon VPC IPAM // User Guide. // // [Enable integration with Organizations]: https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html DisableIpamOrganizationAdminAccount(ctx context.Context, params *ec2.DisableIpamOrganizationAdminAccountInput, optFns ...func(*Options)) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) + // Disables an IPAM policy. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + DisableIpamPolicy(ctx context.Context, params *ec2.DisableIpamPolicyInput, optFns ...func(*Options)) (*ec2.DisableIpamPolicyOutput, error) // Disables route propagation from a route server to a specified route table. // // When enabled, route server propagation installs the routes in the FIB on the @@ -4031,12 +4152,43 @@ type EC2 interface { // // [Protect an Amazon EC2 AMI from deregistration]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deregistration-protection.html EnableImageDeregistrationProtection(ctx context.Context, params *ec2.EnableImageDeregistrationProtectionInput, optFns ...func(*Options)) (*ec2.EnableImageDeregistrationProtectionOutput, error) + // Enable Amazon EC2 instances running in an SQL Server High Availability cluster + // for SQL Server High Availability instance standby detection monitoring. Once + // enabled, Amazon Web Services monitors the metadata for the instances to + // determine whether they are active or standby nodes in the SQL Server High + // Availability cluster. If the instances are determined to be standby failover + // nodes, Amazon Web Services automatically applies SQL Server licensing fee waiver + // for those instances. + // + // To register an instance, it must be running a Windows SQL Server + // license-included AMI and have the Amazon Web Services Systems Manager agent + // installed and running. Only Windows Server 2019 and later and SQL Server + // (Standard and Enterprise editions) 2017 and later are supported. For more + // information, see [Prerequisites for using SQL Server High Availability instance standby detection]. + // + // [Prerequisites for using SQL Server High Availability instance standby detection]: https://docs.aws.amazon.com/sql-server-ec2/latest/userguide/prerequisites-and-requirements.html + EnableInstanceSqlHaStandbyDetections(ctx context.Context, params *ec2.EnableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*Options)) (*ec2.EnableInstanceSqlHaStandbyDetectionsOutput, error) // Enable an Organizations member account as the IPAM admin account. You cannot // select the Organizations management account as the IPAM admin account. For more // information, see [Enable integration with Organizations]in the Amazon VPC IPAM User Guide. // // [Enable integration with Organizations]: https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html EnableIpamOrganizationAdminAccount(ctx context.Context, params *ec2.EnableIpamOrganizationAdminAccountInput, optFns ...func(*Options)) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) + // Enables an IPAM policy. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + // + // For more information, see [Define public IPv4 allocation strategy with IPAM policies] in the Amazon VPC IPAM User Guide. + // + // [Define public IPv4 allocation strategy with IPAM policies]: https://docs.aws.amazon.com/vpc/latest/ipam/define-public-ipv4-allocation-strategy-with-ipam-policies.html + EnableIpamPolicy(ctx context.Context, params *ec2.EnableIpamPolicyInput, optFns ...func(*Options)) (*ec2.EnableIpamPolicyOutput, error) // Establishes a trust relationship between Reachability Analyzer and // Organizations. This operation must be performed by the management account for // the organization. @@ -4236,6 +4388,17 @@ type EC2 interface { // // [Amazon EBS encryption]: https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html GetEbsEncryptionByDefault(ctx context.Context, params *ec2.GetEbsEncryptionByDefaultInput, optFns ...func(*Options)) (*ec2.GetEbsEncryptionByDefaultOutput, error) + // Gets the enabled IPAM policy. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + GetEnabledIpamPolicy(ctx context.Context, params *ec2.GetEnabledIpamPolicyInput, optFns ...func(*Options)) (*ec2.GetEnabledIpamPolicyOutput, error) // Generates a CloudFormation template that streamlines and automates the // integration of VPC flow logs with Amazon Athena. This make it easier for you to // query and gain insights from VPC flow logs data. Based on the information that @@ -4335,6 +4498,35 @@ type EC2 interface { // The following resources can be discovered: VPCs, Public IPv4 pools, VPC subnets, // and Elastic IP addresses. GetIpamDiscoveredResourceCidrs(ctx context.Context, params *ec2.GetIpamDiscoveredResourceCidrsInput, optFns ...func(*Options)) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error) + // Gets the allocation rules for an IPAM policy. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + // + // Allocation rules are optional configurations within an IPAM policy that map + // Amazon Web Services resource types to specific IPAM pools. If no rules are + // defined, the resource types default to using Amazon-provided IP addresses. + GetIpamPolicyAllocationRules(ctx context.Context, params *ec2.GetIpamPolicyAllocationRulesInput, optFns ...func(*Options)) (*ec2.GetIpamPolicyAllocationRulesOutput, error) + // Gets the Amazon Web Services Organizations targets for an IPAM policy. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + // + // A target can be an individual Amazon Web Services account or an entity within + // an Amazon Web Services Organization to which an IPAM policy can be applied. + GetIpamPolicyOrganizationTargets(ctx context.Context, params *ec2.GetIpamPolicyOrganizationTargetsInput, optFns ...func(*Options)) (*ec2.GetIpamPolicyOrganizationTargetsOutput, error) // Get a list of all the CIDR allocations in an IPAM pool. The Region you use // should be the IPAM pool locale. The locale is the Amazon Web Services Region // where this IPAM pool is available for allocations. @@ -4535,6 +4727,8 @@ type EC2 interface { // Lists the route tables to which the specified resource attachment propagates // routes. GetTransitGatewayAttachmentPropagations(ctx context.Context, params *ec2.GetTransitGatewayAttachmentPropagationsInput, optFns ...func(*Options)) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) + // Retrieves the entries for a transit gateway metering policy. + GetTransitGatewayMeteringPolicyEntries(ctx context.Context, params *ec2.GetTransitGatewayMeteringPolicyEntriesInput, optFns ...func(*Options)) (*ec2.GetTransitGatewayMeteringPolicyEntriesOutput, error) // Gets information about the associations for the transit gateway multicast // domain. GetTransitGatewayMulticastDomainAssociations(ctx context.Context, params *ec2.GetTransitGatewayMulticastDomainAssociationsInput, optFns ...func(*Options)) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) @@ -4557,6 +4751,13 @@ type EC2 interface { GetVerifiedAccessEndpointTargets(ctx context.Context, params *ec2.GetVerifiedAccessEndpointTargetsInput, optFns ...func(*Options)) (*ec2.GetVerifiedAccessEndpointTargetsOutput, error) // Shows the contents of the Verified Access policy associated with the group. GetVerifiedAccessGroupPolicy(ctx context.Context, params *ec2.GetVerifiedAccessGroupPolicyInput, optFns ...func(*Options)) (*ec2.GetVerifiedAccessGroupPolicyOutput, error) + // Gets information about resources in a VPC that are blocking encryption + // enforcement. + // + // For more information, see [Enforce VPC encryption in transit] in the Amazon VPC User Guide. + // + // [Enforce VPC encryption in transit]: https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html + GetVpcResourcesBlockingEncryptionEnforcement(ctx context.Context, params *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, optFns ...func(*Options)) (*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, error) // Download an Amazon Web Services-provided sample configuration file to be used // with the customer gateway device specified for your Site-to-Site VPN connection. GetVpnConnectionDeviceSampleConfiguration(ctx context.Context, params *ec2.GetVpnConnectionDeviceSampleConfigurationInput, optFns ...func(*Options)) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) @@ -4643,6 +4844,8 @@ type EC2 interface { ListImagesInRecycleBin(ctx context.Context, params *ec2.ListImagesInRecycleBinInput, optFns ...func(*Options)) (*ec2.ListImagesInRecycleBinOutput, error) // Lists one or more snapshots that are currently in the Recycle Bin. ListSnapshotsInRecycleBin(ctx context.Context, params *ec2.ListSnapshotsInRecycleBinInput, optFns ...func(*Options)) (*ec2.ListSnapshotsInRecycleBinOutput, error) + // Lists one or more volumes that are currently in the Recycle Bin. + ListVolumesInRecycleBin(ctx context.Context, params *ec2.ListVolumesInRecycleBinInput, optFns ...func(*Options)) (*ec2.ListVolumesInRecycleBinOutput, error) // Locks an Amazon EBS snapshot in either governance or compliance mode to protect // it against accidental or malicious deletions for a specific duration. A locked // snapshot can't be deleted. @@ -4969,6 +5172,21 @@ type EC2 interface { ModifyInstancePlacement(ctx context.Context, params *ec2.ModifyInstancePlacementInput, optFns ...func(*Options)) (*ec2.ModifyInstancePlacementOutput, error) // Modify the configurations of an IPAM. ModifyIpam(ctx context.Context, params *ec2.ModifyIpamInput, optFns ...func(*Options)) (*ec2.ModifyIpamOutput, error) + // Modifies the allocation rules in an IPAM policy. + // + // An IPAM policy is a set of rules that define how public IPv4 addresses from + // IPAM pools are allocated to Amazon Web Services resources. Each rule maps an + // Amazon Web Services service to IPAM pools that the service will use to get IP + // addresses. A single policy can have multiple rules and be applied to multiple + // Amazon Web Services Regions. If the IPAM pool run out of addresses then the + // services fallback to Amazon-provided IP addresses. A policy can be applied to an + // individual Amazon Web Services account or an entity within Amazon Web Services + // Organizations. + // + // Allocation rules are optional configurations within an IPAM policy that map + // Amazon Web Services resource types to specific IPAM pools. If no rules are + // defined, the resource types default to using Amazon-provided IP addresses. + ModifyIpamPolicyAllocationRules(ctx context.Context, params *ec2.ModifyIpamPolicyAllocationRulesInput, optFns ...func(*Options)) (*ec2.ModifyIpamPolicyAllocationRulesOutput, error) // Modify the configurations of an IPAM pool. // // For more information, see [Modify a pool] in the Amazon VPC IPAM User Guide. @@ -5154,6 +5372,8 @@ type EC2 interface { // modified options are applied to new transit gateway attachments only. Your // existing transit gateway attachments are not modified. ModifyTransitGateway(ctx context.Context, params *ec2.ModifyTransitGatewayInput, optFns ...func(*Options)) (*ec2.ModifyTransitGatewayOutput, error) + // Modifies a transit gateway metering policy. + ModifyTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.ModifyTransitGatewayMeteringPolicyInput, optFns ...func(*Options)) (*ec2.ModifyTransitGatewayMeteringPolicyOutput, error) // Modifies a reference (route) to a prefix list in a specified transit gateway // route table. ModifyTransitGatewayPrefixListReference(ctx context.Context, params *ec2.ModifyTransitGatewayPrefixListReferenceInput, optFns ...func(*Options)) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) @@ -5229,6 +5449,14 @@ type EC2 interface { // // [Block public access to VPCs and subnets]: https://docs.aws.amazon.com/vpc/latest/userguide/security-vpc-bpa.html ModifyVpcBlockPublicAccessOptions(ctx context.Context, params *ec2.ModifyVpcBlockPublicAccessOptionsInput, optFns ...func(*Options)) (*ec2.ModifyVpcBlockPublicAccessOptionsOutput, error) + // Modifies the encryption control configuration for a VPC. You can update the + // encryption mode and exclusion settings for various gateway types and peering + // connections. + // + // For more information, see [Enforce VPC encryption in transit] in the Amazon VPC User Guide. + // + // [Enforce VPC encryption in transit]: https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html + ModifyVpcEncryptionControl(ctx context.Context, params *ec2.ModifyVpcEncryptionControlInput, optFns ...func(*Options)) (*ec2.ModifyVpcEncryptionControlOutput, error) // Modifies attributes of a specified VPC endpoint. The attributes that you can // modify depend on the type of VPC endpoint (interface, gateway, or Gateway Load // Balancer). For more information, see the [Amazon Web Services PrivateLink Guide]. @@ -5795,6 +6023,11 @@ type EC2 interface { // [Restore an archived snapshot]: https://docs.aws.amazon.com/ebs/latest/userguide/working-with-snapshot-archiving.html#restore-archived-snapshot // [modify the restore period or restore type for a temporarily restored snapshot]: https://docs.aws.amazon.com/ebs/latest/userguide/working-with-snapshot-archiving.html#modify-temp-restore-period RestoreSnapshotTier(ctx context.Context, params *ec2.RestoreSnapshotTierInput, optFns ...func(*Options)) (*ec2.RestoreSnapshotTierOutput, error) + // Restores a volume from the Recycle Bin. For more information, see [Restore volumes from the Recycle Bin] in the + // Amazon EBS User Guide. + // + // [Restore volumes from the Recycle Bin]: https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-volumes.html#recycle-bin-restore-volumes + RestoreVolumeFromRecycleBin(ctx context.Context, params *ec2.RestoreVolumeFromRecycleBinInput, optFns ...func(*Options)) (*ec2.RestoreVolumeFromRecycleBinOutput, error) // Removes an ingress authorization rule from a Client VPN endpoint. RevokeClientVpnIngress(ctx context.Context, params *ec2.RevokeClientVpnIngressInput, optFns ...func(*Options)) (*ec2.RevokeClientVpnIngressOutput, error) // Removes the specified outbound (egress) rules from the specified security group. @@ -6173,6 +6406,11 @@ type EC2 interface { // controls whether Capacity Manager can aggregate data from all accounts in your // Amazon Web Services Organization or only from the current account. UpdateCapacityManagerOrganizationsAccess(ctx context.Context, params *ec2.UpdateCapacityManagerOrganizationsAccessInput, optFns ...func(*Options)) (*ec2.UpdateCapacityManagerOrganizationsAccessOutput, error) + // Modifies the number of instances allocated to an interruptible reservation, + // + // allowing you to add more capacity or reclaim capacity to your source Capacity + // Reservation. + UpdateInterruptibleCapacityReservationAllocation(ctx context.Context, params *ec2.UpdateInterruptibleCapacityReservationAllocationInput, optFns ...func(*Options)) (*ec2.UpdateInterruptibleCapacityReservationAllocationOutput, error) // Updates the description of an egress (outbound) security group rule. You can // replace an existing description, or add a description to a rule that did not // have one previously. You can remove a description for a security group rule by diff --git a/pkg/awsapi/eks.go b/pkg/awsapi/eks.go index f7bc498ab4..2ae8e48beb 100644 --- a/pkg/awsapi/eks.go +++ b/pkg/awsapi/eks.go @@ -72,10 +72,10 @@ type EKS interface { // single tenant and unique. It runs on its own set of Amazon EC2 instances. // // The cluster control plane is provisioned across multiple Availability Zones and - // fronted by an Elastic Load Balancing Network Load Balancer. Amazon EKS also - // provisions elastic network interfaces in your VPC subnets to provide - // connectivity from the control plane instances to the nodes (for example, to - // support kubectl exec , logs , and proxy data flows). + // fronted by an ELB Network Load Balancer. Amazon EKS also provisions elastic + // network interfaces in your VPC subnets to provide connectivity from the control + // plane instances to the nodes (for example, to support kubectl exec , logs , and + // proxy data flows). // // Amazon EKS nodes run in your Amazon Web Services account and connect to your // cluster's control plane over the Kubernetes API server endpoint and a @@ -160,9 +160,9 @@ type EKS interface { // node group was created. You can update the launch template version with // necessary changes. For more information about using launch templates, see [Customizing managed nodes with launch templates]. // - // An Amazon EKS managed node group is an Amazon EC2 Auto Scaling group and - // associated Amazon EC2 instances that are managed by Amazon Web Services for an - // Amazon EKS cluster. For more information, see [Managed node groups]in the Amazon EKS User Guide. + // An Amazon EKS managed node group is an Amazon EC2 Amazon EC2 Auto Scaling group + // and associated Amazon EC2 instances that are managed by Amazon Web Services for + // an Amazon EKS cluster. For more information, see [Managed node groups]in the Amazon EKS User Guide. // // Windows AMI types are only supported for commercial Amazon Web Services Regions // that support Windows on Amazon EKS. diff --git a/pkg/awsapi/elasticloadbalancingv2.go b/pkg/awsapi/elasticloadbalancingv2.go index ca6d68bf8a..e1f9d8c3b5 100644 --- a/pkg/awsapi/elasticloadbalancingv2.go +++ b/pkg/awsapi/elasticloadbalancingv2.go @@ -221,7 +221,7 @@ type ELBV2 interface { // Describes the specified load balancers or all of your load balancers. DescribeLoadBalancers(ctx context.Context, params *elasticloadbalancingv2.DescribeLoadBalancersInput, optFns ...func(*Options)) (*elasticloadbalancingv2.DescribeLoadBalancersOutput, error) // Describes the specified rules or the rules for the specified listener. You must - // specify either a listener or one or more rules. + // specify either a listener or rules. DescribeRules(ctx context.Context, params *elasticloadbalancingv2.DescribeRulesInput, optFns ...func(*Options)) (*elasticloadbalancingv2.DescribeRulesOutput, error) // Describes the specified policies or all policies used for SSL negotiation. // diff --git a/pkg/awsapi/iam.go b/pkg/awsapi/iam.go index 55999dd56a..352a56113b 100644 --- a/pkg/awsapi/iam.go +++ b/pkg/awsapi/iam.go @@ -17,6 +17,21 @@ type IAM interface { // config. Config overrides should instead be made on a per-operation basis through // functional options. Options() iam.Options + // Accepts a delegation request, granting the requested temporary access. + // + // Once the delegation request is accepted, it is eligible to send the exchange + // token to the partner. The [SendDelegationToken]API has to be explicitly called to send the + // delegation token. + // + // At the time of acceptance, IAM records the details and the state of the + // identity that called this API. This is the identity that gets mapped to the + // delegated credential. + // + // An accepted request may be rejected before the exchange token is sent to the + // partner. + // + // [SendDelegationToken]: https://docs.aws.amazon.com/IAM/latest/APIReference/API_SendDelegationToken.html + AcceptDelegationRequest(ctx context.Context, params *iam.AcceptDelegationRequestInput, optFns ...func(*Options)) (*iam.AcceptDelegationRequestOutput, error) // Adds a new client ID (also known as audience) to the list of client IDs already // registered for the specified IAM OpenID Connect (OIDC) provider resource. // @@ -53,6 +68,25 @@ type IAM interface { AddRoleToInstanceProfile(ctx context.Context, params *iam.AddRoleToInstanceProfileInput, optFns ...func(*Options)) (*iam.AddRoleToInstanceProfileOutput, error) // Adds the specified user to the specified group. AddUserToGroup(ctx context.Context, params *iam.AddUserToGroupInput, optFns ...func(*Options)) (*iam.AddUserToGroupOutput, error) + // Associates a delegation request with the current identity. + // + // If the partner that created the delegation request has specified the owner + // account during creation, only an identity from that owner account can call the + // AssociateDelegationRequest API for the specified delegation request. Once the + // AssociateDelegationRequest API call is successful, the ARN of the current + // calling identity will be stored as the ownerId of the request. + // + // If the partner that created the delegation request has not specified the owner + // account during creation, any caller from any account can call the + // AssociateDelegationRequest API for the delegation request. Once this API call is + // successful, the ARN of the current calling identity will be stored as the + // ownerId and the Amazon Web Services account ID of the current calling identity + // will be stored as the ownerAccount of the request. + // + // For more details, see [Managing Permissions for Delegation Requests]. + // + // [Managing Permissions for Delegation Requests]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions + AssociateDelegationRequest(ctx context.Context, params *iam.AssociateDelegationRequestInput, optFns ...func(*Options)) (*iam.AssociateDelegationRequestOutput, error) // Attaches the specified managed policy to the specified IAM group. // // You use this operation to attach a managed policy to a group. To embed an @@ -144,7 +178,12 @@ type IAM interface { // // [Creating, deleting, and listing an Amazon Web Services account alias]: https://docs.aws.amazon.com/signin/latest/userguide/CreateAccountAlias.html CreateAccountAlias(ctx context.Context, params *iam.CreateAccountAliasInput, optFns ...func(*Options)) (*iam.CreateAccountAliasOutput, error) - // This API is currently unavailable for general use. + // Creates an IAM delegation request for temporary access delegation. + // + // This API is not available for general use. In order to use this API, a caller + // first need to go through an onboarding process described in the [partner onboarding documentation]. + // + // [partner onboarding documentation]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation-partner-guide.html CreateDelegationRequest(ctx context.Context, params *iam.CreateDelegationRequestInput, optFns ...func(*Options)) (*iam.CreateDelegationRequestOutput, error) // Creates a new group. // @@ -659,6 +698,12 @@ type IAM interface { // delegated administrator for IAM can no longer perform privileged tasks on member // accounts in your organization. DisableOrganizationsRootSessions(ctx context.Context, params *iam.DisableOrganizationsRootSessionsInput, optFns ...func(*Options)) (*iam.DisableOrganizationsRootSessionsOutput, error) + // Disables the outbound identity federation feature for your Amazon Web Services + // account. When disabled, IAM principals in the account cannot use the + // GetWebIdentityToken API to obtain JSON Web Tokens (JWTs) for authentication with + // external services. This operation does not affect tokens that were issued before + // the feature was disabled. + DisableOutboundWebIdentityFederation(ctx context.Context, params *iam.DisableOutboundWebIdentityFederationInput, optFns ...func(*Options)) (*iam.DisableOutboundWebIdentityFederationOutput, error) // Enables the specified MFA device and associates it with the specified IAM user. // When enabled, the MFA device is required for every subsequent login by the IAM // user associated with the device. @@ -696,6 +741,12 @@ type IAM interface { // [Organizations]: https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html // [IAM and Organizations]: https://docs.aws.amazon.com/organizations/latest/userguide/services-that-can-integrate-ra.html EnableOrganizationsRootSessions(ctx context.Context, params *iam.EnableOrganizationsRootSessionsInput, optFns ...func(*Options)) (*iam.EnableOrganizationsRootSessionsOutput, error) + // Enables the outbound identity federation feature for your Amazon Web Services + // account. When enabled, IAM principals in your account can use the + // GetWebIdentityToken API to obtain JSON Web Tokens (JWTs) for secure + // authentication with external services. This operation also generates a unique + // issuer URL for your Amazon Web Services account. + EnableOutboundWebIdentityFederation(ctx context.Context, params *iam.EnableOutboundWebIdentityFederationInput, optFns ...func(*Options)) (*iam.EnableOutboundWebIdentityFederationOutput, error) // Generates a credential report for the Amazon Web Services account. For more // // information about the credential report, see [Getting credential reports]in the IAM User Guide. @@ -958,6 +1009,17 @@ type IAM interface { // // [Getting credential reports]: https://docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html GetCredentialReport(ctx context.Context, params *iam.GetCredentialReportInput, optFns ...func(*Options)) (*iam.GetCredentialReportOutput, error) + // Retrieves information about a specific delegation request. + // + // If a delegation request has no owner or owner account, GetDelegationRequest for + // that delegation request can be called by any account. If the owner account is + // assigned but there is no owner id, only identities within that owner account can + // call GetDelegationRequest for the delegation request. Once the delegation + // request is fully owned, the owner of the request gets a default permission to + // get that delegation request. For more details, see [Managing Permissions for Delegation Requests]. + // + // [Managing Permissions for Delegation Requests]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions + GetDelegationRequest(ctx context.Context, params *iam.GetDelegationRequestInput, optFns ...func(*Options)) (*iam.GetDelegationRequestOutput, error) // Returns a list of IAM users that are in the specified IAM group. You can // // paginate the results using the MaxItems and Marker parameters. @@ -982,6 +1044,23 @@ type IAM interface { // [GetPolicy]: https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html // [Managed policies and inline policies]: https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html GetGroupPolicy(ctx context.Context, params *iam.GetGroupPolicyInput, optFns ...func(*Options)) (*iam.GetGroupPolicyOutput, error) + // Retrieves a human readable summary for a given entity. At this time, the only + // supported entity type is delegation-request + // + // This method uses a Large Language Model (LLM) to generate the summary. + // + // If a delegation request has no owner or owner account, GetHumanReadableSummary + // for that delegation request can be called by any account. If the owner account + // is assigned but there is no owner id, only identities within that owner account + // can call GetHumanReadableSummary for the delegation request to retrieve a + // summary of that request. Once the delegation request is fully owned, the owner + // of the request gets a default permission to get that delegation request. For + // more details, read default permissions granted to delegation requests. These rules are identical to [GetDelegationRequest] API behavior, such that a + // party who has permissions to call [GetDelegationRequest]for a given delegation request will always be + // able to retrieve the human readable summary for that request. + // + // [GetDelegationRequest]: https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetDelegationRequest.html + GetHumanReadableSummary(ctx context.Context, params *iam.GetHumanReadableSummaryInput, optFns ...func(*Options)) (*iam.GetHumanReadableSummaryOutput, error) // Retrieves information about the specified instance profile, including the // // instance profile's path, GUID, ARN, and role. For more information about @@ -1031,6 +1110,12 @@ type IAM interface { // [GenerateOrganizationsAccessReport]: https://docs.aws.amazon.com/IAM/latest/APIReference/API_GenerateOrganizationsAccessReport.html // [Refining permissions using service last accessed data]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html GetOrganizationsAccessReport(ctx context.Context, params *iam.GetOrganizationsAccessReportInput, optFns ...func(*Options)) (*iam.GetOrganizationsAccessReportOutput, error) + // Retrieves the configuration information for the outbound identity federation + // feature in your Amazon Web Services account. The response includes the unique + // issuer URL for your Amazon Web Services account and the current enabled/disabled + // status of the feature. Use this operation to obtain the issuer URL that you need + // to configure trust relationships with external services. + GetOutboundWebIdentityFederationInfo(ctx context.Context, params *iam.GetOutboundWebIdentityFederationInfoInput, optFns ...func(*Options)) (*iam.GetOutboundWebIdentityFederationInfoOutput, error) // Retrieves information about the specified managed policy, including the // policy's default version and the total number of IAM users, groups, and roles to // which the policy is attached. To retrieve the list of the specific users, @@ -1314,6 +1399,16 @@ type IAM interface { // [ListUserPolicies]: https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUserPolicies.html // [Managed policies and inline policies]: https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html ListAttachedUserPolicies(ctx context.Context, params *iam.ListAttachedUserPoliciesInput, optFns ...func(*Options)) (*iam.ListAttachedUserPoliciesOutput, error) + // Lists delegation requests based on the specified criteria. + // + // If a delegation request has no owner, even if it is assigned to a specific + // account, it will not be part of the ListDelegationRequests output for that + // account. + // + // For more details, see [Managing Permissions for Delegation Requests]. + // + // [Managing Permissions for Delegation Requests]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions + ListDelegationRequests(ctx context.Context, params *iam.ListDelegationRequestsInput, optFns ...func(*Options)) (*iam.ListDelegationRequestsOutput, error) // Lists all IAM users, groups, and roles that the specified managed policy is // attached to. // @@ -1753,6 +1848,18 @@ type IAM interface { // [AttachUserPolicy]: https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html // [Managed policies and inline policies]: https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html PutUserPolicy(ctx context.Context, params *iam.PutUserPolicyInput, optFns ...func(*Options)) (*iam.PutUserPolicyOutput, error) + // Rejects a delegation request, denying the requested temporary access. + // + // Once a request is rejected, it cannot be accepted or updated later. Rejected + // requests expire after 7 days. + // + // When rejecting a request, an optional explanation can be added using the Notes + // request parameter. + // + // For more details, see [Managing Permissions for Delegation Requests]. + // + // [Managing Permissions for Delegation Requests]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions + RejectDelegationRequest(ctx context.Context, params *iam.RejectDelegationRequestInput, optFns ...func(*Options)) (*iam.RejectDelegationRequestOutput, error) // Removes the specified client ID (also known as audience) from the list of // client IDs registered for the specified IAM OpenID Connect (OIDC) provider // resource object. @@ -1788,6 +1895,20 @@ type IAM interface { // // [Using a virtual MFA device]: https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html ResyncMFADevice(ctx context.Context, params *iam.ResyncMFADeviceInput, optFns ...func(*Options)) (*iam.ResyncMFADeviceOutput, error) + // Sends the exchange token for an accepted delegation request. + // + // The exchange token is sent to the partner via an asynchronous notification + // channel, established by the partner. + // + // The delegation request must be in the ACCEPTED state when calling this API. + // After the SendDelegationToken API call is successful, the request transitions + // to a FINALIZED state and cannot be rolled back. However, a user may reject an + // accepted request before the SendDelegationToken API is called. + // + // For more details, see [Managing Permissions for Delegation Requests]. + // + // [Managing Permissions for Delegation Requests]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions + SendDelegationToken(ctx context.Context, params *iam.SendDelegationTokenInput, optFns ...func(*Options)) (*iam.SendDelegationTokenOutput, error) // Sets the specified version of the specified policy as the policy's default // (operative) version. // @@ -2227,6 +2348,14 @@ type IAM interface { // // [Using roles to delegate permissions and federate identities]: https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html UpdateAssumeRolePolicy(ctx context.Context, params *iam.UpdateAssumeRolePolicyInput, optFns ...func(*Options)) (*iam.UpdateAssumeRolePolicyOutput, error) + // Updates an existing delegation request with additional information. When the + // delegation request is updated, it reaches the PENDING_APPROVAL state. + // + // Once a delegation request has an owner, that owner gets a default permission to + // update the delegation request. For more details, see [Managing Permissions for Delegation Requests]. + // + // [Managing Permissions for Delegation Requests]: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions + UpdateDelegationRequest(ctx context.Context, params *iam.UpdateDelegationRequestInput, optFns ...func(*Options)) (*iam.UpdateDelegationRequestOutput, error) // Updates the name and/or the path of the specified IAM group. // // You should understand the implications of changing a group's path or name. For diff --git a/pkg/eks/mocksv2/ASG.go b/pkg/eks/mocksv2/ASG.go index 83d30d51ce..abad2f9c86 100644 --- a/pkg/eks/mocksv2/ASG.go +++ b/pkg/eks/mocksv2/ASG.go @@ -3723,6 +3723,80 @@ func (_c *ASG_GetPredictiveScalingForecast_Call) RunAndReturn(run func(context.C return _c } +// LaunchInstances provides a mock function with given fields: ctx, params, optFns +func (_m *ASG) LaunchInstances(ctx context.Context, params *autoscaling.LaunchInstancesInput, optFns ...func(*autoscaling.Options)) (*autoscaling.LaunchInstancesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for LaunchInstances") + } + + var r0 *autoscaling.LaunchInstancesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *autoscaling.LaunchInstancesInput, ...func(*autoscaling.Options)) (*autoscaling.LaunchInstancesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *autoscaling.LaunchInstancesInput, ...func(*autoscaling.Options)) *autoscaling.LaunchInstancesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*autoscaling.LaunchInstancesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *autoscaling.LaunchInstancesInput, ...func(*autoscaling.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ASG_LaunchInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LaunchInstances' +type ASG_LaunchInstances_Call struct { + *mock.Call +} + +// LaunchInstances is a helper method to define mock.On call +// - ctx context.Context +// - params *autoscaling.LaunchInstancesInput +// - optFns ...func(*autoscaling.Options) +func (_e *ASG_Expecter) LaunchInstances(ctx interface{}, params interface{}, optFns ...interface{}) *ASG_LaunchInstances_Call { + return &ASG_LaunchInstances_Call{Call: _e.mock.On("LaunchInstances", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *ASG_LaunchInstances_Call) Run(run func(ctx context.Context, params *autoscaling.LaunchInstancesInput, optFns ...func(*autoscaling.Options))) *ASG_LaunchInstances_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*autoscaling.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*autoscaling.Options)) + } + } + run(args[0].(context.Context), args[1].(*autoscaling.LaunchInstancesInput), variadicArgs...) + }) + return _c +} + +func (_c *ASG_LaunchInstances_Call) Return(_a0 *autoscaling.LaunchInstancesOutput, _a1 error) *ASG_LaunchInstances_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *ASG_LaunchInstances_Call) RunAndReturn(run func(context.Context, *autoscaling.LaunchInstancesInput, ...func(*autoscaling.Options)) (*autoscaling.LaunchInstancesOutput, error)) *ASG_LaunchInstances_Call { + _c.Call.Return(run) + return _c +} + // Options provides a mock function with no fields func (_m *ASG) Options() autoscaling.Options { ret := _m.Called() diff --git a/pkg/eks/mocksv2/CloudFormation.go b/pkg/eks/mocksv2/CloudFormation.go index 370140bb1f..61f51e1551 100644 --- a/pkg/eks/mocksv2/CloudFormation.go +++ b/pkg/eks/mocksv2/CloudFormation.go @@ -1651,6 +1651,80 @@ func (_c *CloudFormation_DescribeChangeSetHooks_Call) RunAndReturn(run func(cont return _c } +// DescribeEvents provides a mock function with given fields: ctx, params, optFns +func (_m *CloudFormation) DescribeEvents(ctx context.Context, params *cloudformation.DescribeEventsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeEventsOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeEvents") + } + + var r0 *cloudformation.DescribeEventsOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeEventsInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeEventsOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeEventsInput, ...func(*cloudformation.Options)) *cloudformation.DescribeEventsOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudformation.DescribeEventsOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeEventsInput, ...func(*cloudformation.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudFormation_DescribeEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeEvents' +type CloudFormation_DescribeEvents_Call struct { + *mock.Call +} + +// DescribeEvents is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudformation.DescribeEventsInput +// - optFns ...func(*cloudformation.Options) +func (_e *CloudFormation_Expecter) DescribeEvents(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeEvents_Call { + return &CloudFormation_DescribeEvents_Call{Call: _e.mock.On("DescribeEvents", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudFormation_DescribeEvents_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeEventsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeEvents_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudformation.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudformation.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudformation.DescribeEventsInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudFormation_DescribeEvents_Call) Return(_a0 *cloudformation.DescribeEventsOutput, _a1 error) *CloudFormation_DescribeEvents_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudFormation_DescribeEvents_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeEventsInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeEventsOutput, error)) *CloudFormation_DescribeEvents_Call { + _c.Call.Return(run) + return _c +} + // DescribeGeneratedTemplate provides a mock function with given fields: ctx, params, optFns func (_m *CloudFormation) DescribeGeneratedTemplate(ctx context.Context, params *cloudformation.DescribeGeneratedTemplateInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeGeneratedTemplateOutput, error) { _va := make([]interface{}, len(optFns)) @@ -3353,6 +3427,80 @@ func (_c *CloudFormation_GetGeneratedTemplate_Call) RunAndReturn(run func(contex return _c } +// GetHookResult provides a mock function with given fields: ctx, params, optFns +func (_m *CloudFormation) GetHookResult(ctx context.Context, params *cloudformation.GetHookResultInput, optFns ...func(*cloudformation.Options)) (*cloudformation.GetHookResultOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetHookResult") + } + + var r0 *cloudformation.GetHookResultOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetHookResultInput, ...func(*cloudformation.Options)) (*cloudformation.GetHookResultOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetHookResultInput, ...func(*cloudformation.Options)) *cloudformation.GetHookResultOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudformation.GetHookResultOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.GetHookResultInput, ...func(*cloudformation.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudFormation_GetHookResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHookResult' +type CloudFormation_GetHookResult_Call struct { + *mock.Call +} + +// GetHookResult is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudformation.GetHookResultInput +// - optFns ...func(*cloudformation.Options) +func (_e *CloudFormation_Expecter) GetHookResult(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_GetHookResult_Call { + return &CloudFormation_GetHookResult_Call{Call: _e.mock.On("GetHookResult", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudFormation_GetHookResult_Call) Run(run func(ctx context.Context, params *cloudformation.GetHookResultInput, optFns ...func(*cloudformation.Options))) *CloudFormation_GetHookResult_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudformation.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudformation.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudformation.GetHookResultInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudFormation_GetHookResult_Call) Return(_a0 *cloudformation.GetHookResultOutput, _a1 error) *CloudFormation_GetHookResult_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudFormation_GetHookResult_Call) RunAndReturn(run func(context.Context, *cloudformation.GetHookResultInput, ...func(*cloudformation.Options)) (*cloudformation.GetHookResultOutput, error)) *CloudFormation_GetHookResult_Call { + _c.Call.Return(run) + return _c +} + // GetStackPolicy provides a mock function with given fields: ctx, params, optFns func (_m *CloudFormation) GetStackPolicy(ctx context.Context, params *cloudformation.GetStackPolicyInput, optFns ...func(*cloudformation.Options)) (*cloudformation.GetStackPolicyOutput, error) { _va := make([]interface{}, len(optFns)) diff --git a/pkg/eks/mocksv2/CloudTrail.go b/pkg/eks/mocksv2/CloudTrail.go index 5d1015c84c..ba7b4ff04c 100644 --- a/pkg/eks/mocksv2/CloudTrail.go +++ b/pkg/eks/mocksv2/CloudTrail.go @@ -2465,6 +2465,80 @@ func (_c *CloudTrail_ListImports_Call) RunAndReturn(run func(context.Context, *c return _c } +// ListInsightsData provides a mock function with given fields: ctx, params, optFns +func (_m *CloudTrail) ListInsightsData(ctx context.Context, params *cloudtrail.ListInsightsDataInput, optFns ...func(*cloudtrail.Options)) (*cloudtrail.ListInsightsDataOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListInsightsData") + } + + var r0 *cloudtrail.ListInsightsDataOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudtrail.ListInsightsDataInput, ...func(*cloudtrail.Options)) (*cloudtrail.ListInsightsDataOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudtrail.ListInsightsDataInput, ...func(*cloudtrail.Options)) *cloudtrail.ListInsightsDataOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudtrail.ListInsightsDataOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudtrail.ListInsightsDataInput, ...func(*cloudtrail.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudTrail_ListInsightsData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListInsightsData' +type CloudTrail_ListInsightsData_Call struct { + *mock.Call +} + +// ListInsightsData is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudtrail.ListInsightsDataInput +// - optFns ...func(*cloudtrail.Options) +func (_e *CloudTrail_Expecter) ListInsightsData(ctx interface{}, params interface{}, optFns ...interface{}) *CloudTrail_ListInsightsData_Call { + return &CloudTrail_ListInsightsData_Call{Call: _e.mock.On("ListInsightsData", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudTrail_ListInsightsData_Call) Run(run func(ctx context.Context, params *cloudtrail.ListInsightsDataInput, optFns ...func(*cloudtrail.Options))) *CloudTrail_ListInsightsData_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudtrail.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudtrail.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudtrail.ListInsightsDataInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudTrail_ListInsightsData_Call) Return(_a0 *cloudtrail.ListInsightsDataOutput, _a1 error) *CloudTrail_ListInsightsData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudTrail_ListInsightsData_Call) RunAndReturn(run func(context.Context, *cloudtrail.ListInsightsDataInput, ...func(*cloudtrail.Options)) (*cloudtrail.ListInsightsDataOutput, error)) *CloudTrail_ListInsightsData_Call { + _c.Call.Return(run) + return _c +} + // ListInsightsMetricData provides a mock function with given fields: ctx, params, optFns func (_m *CloudTrail) ListInsightsMetricData(ctx context.Context, params *cloudtrail.ListInsightsMetricDataInput, optFns ...func(*cloudtrail.Options)) (*cloudtrail.ListInsightsMetricDataOutput, error) { _va := make([]interface{}, len(optFns)) diff --git a/pkg/eks/mocksv2/CloudWatchLogs.go b/pkg/eks/mocksv2/CloudWatchLogs.go index 8b1fe4eb24..ba3e7a2bd9 100644 --- a/pkg/eks/mocksv2/CloudWatchLogs.go +++ b/pkg/eks/mocksv2/CloudWatchLogs.go @@ -541,6 +541,80 @@ func (_c *CloudWatchLogs_CreateLogStream_Call) RunAndReturn(run func(context.Con return _c } +// CreateScheduledQuery provides a mock function with given fields: ctx, params, optFns +func (_m *CloudWatchLogs) CreateScheduledQuery(ctx context.Context, params *cloudwatchlogs.CreateScheduledQueryInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.CreateScheduledQueryOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateScheduledQuery") + } + + var r0 *cloudwatchlogs.CreateScheduledQueryOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.CreateScheduledQueryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.CreateScheduledQueryOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.CreateScheduledQueryInput, ...func(*cloudwatchlogs.Options)) *cloudwatchlogs.CreateScheduledQueryOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudwatchlogs.CreateScheduledQueryOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudwatchlogs.CreateScheduledQueryInput, ...func(*cloudwatchlogs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudWatchLogs_CreateScheduledQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateScheduledQuery' +type CloudWatchLogs_CreateScheduledQuery_Call struct { + *mock.Call +} + +// CreateScheduledQuery is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudwatchlogs.CreateScheduledQueryInput +// - optFns ...func(*cloudwatchlogs.Options) +func (_e *CloudWatchLogs_Expecter) CreateScheduledQuery(ctx interface{}, params interface{}, optFns ...interface{}) *CloudWatchLogs_CreateScheduledQuery_Call { + return &CloudWatchLogs_CreateScheduledQuery_Call{Call: _e.mock.On("CreateScheduledQuery", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudWatchLogs_CreateScheduledQuery_Call) Run(run func(ctx context.Context, params *cloudwatchlogs.CreateScheduledQueryInput, optFns ...func(*cloudwatchlogs.Options))) *CloudWatchLogs_CreateScheduledQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudwatchlogs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudwatchlogs.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudwatchlogs.CreateScheduledQueryInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudWatchLogs_CreateScheduledQuery_Call) Return(_a0 *cloudwatchlogs.CreateScheduledQueryOutput, _a1 error) *CloudWatchLogs_CreateScheduledQuery_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudWatchLogs_CreateScheduledQuery_Call) RunAndReturn(run func(context.Context, *cloudwatchlogs.CreateScheduledQueryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.CreateScheduledQueryOutput, error)) *CloudWatchLogs_CreateScheduledQuery_Call { + _c.Call.Return(run) + return _c +} + // DeleteAccountPolicy provides a mock function with given fields: ctx, params, optFns func (_m *CloudWatchLogs) DeleteAccountPolicy(ctx context.Context, params *cloudwatchlogs.DeleteAccountPolicyInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DeleteAccountPolicyOutput, error) { _va := make([]interface{}, len(optFns)) @@ -1725,6 +1799,80 @@ func (_c *CloudWatchLogs_DeleteRetentionPolicy_Call) RunAndReturn(run func(conte return _c } +// DeleteScheduledQuery provides a mock function with given fields: ctx, params, optFns +func (_m *CloudWatchLogs) DeleteScheduledQuery(ctx context.Context, params *cloudwatchlogs.DeleteScheduledQueryInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DeleteScheduledQueryOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteScheduledQuery") + } + + var r0 *cloudwatchlogs.DeleteScheduledQueryOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.DeleteScheduledQueryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DeleteScheduledQueryOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.DeleteScheduledQueryInput, ...func(*cloudwatchlogs.Options)) *cloudwatchlogs.DeleteScheduledQueryOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudwatchlogs.DeleteScheduledQueryOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudwatchlogs.DeleteScheduledQueryInput, ...func(*cloudwatchlogs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudWatchLogs_DeleteScheduledQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteScheduledQuery' +type CloudWatchLogs_DeleteScheduledQuery_Call struct { + *mock.Call +} + +// DeleteScheduledQuery is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudwatchlogs.DeleteScheduledQueryInput +// - optFns ...func(*cloudwatchlogs.Options) +func (_e *CloudWatchLogs_Expecter) DeleteScheduledQuery(ctx interface{}, params interface{}, optFns ...interface{}) *CloudWatchLogs_DeleteScheduledQuery_Call { + return &CloudWatchLogs_DeleteScheduledQuery_Call{Call: _e.mock.On("DeleteScheduledQuery", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudWatchLogs_DeleteScheduledQuery_Call) Run(run func(ctx context.Context, params *cloudwatchlogs.DeleteScheduledQueryInput, optFns ...func(*cloudwatchlogs.Options))) *CloudWatchLogs_DeleteScheduledQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudwatchlogs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudwatchlogs.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudwatchlogs.DeleteScheduledQueryInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudWatchLogs_DeleteScheduledQuery_Call) Return(_a0 *cloudwatchlogs.DeleteScheduledQueryOutput, _a1 error) *CloudWatchLogs_DeleteScheduledQuery_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudWatchLogs_DeleteScheduledQuery_Call) RunAndReturn(run func(context.Context, *cloudwatchlogs.DeleteScheduledQueryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DeleteScheduledQueryOutput, error)) *CloudWatchLogs_DeleteScheduledQuery_Call { + _c.Call.Return(run) + return _c +} + // DeleteSubscriptionFilter provides a mock function with given fields: ctx, params, optFns func (_m *CloudWatchLogs) DeleteSubscriptionFilter(ctx context.Context, params *cloudwatchlogs.DeleteSubscriptionFilterInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.DeleteSubscriptionFilterOutput, error) { _va := make([]interface{}, len(optFns)) @@ -4093,6 +4241,154 @@ func (_c *CloudWatchLogs_GetQueryResults_Call) RunAndReturn(run func(context.Con return _c } +// GetScheduledQuery provides a mock function with given fields: ctx, params, optFns +func (_m *CloudWatchLogs) GetScheduledQuery(ctx context.Context, params *cloudwatchlogs.GetScheduledQueryInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetScheduledQueryOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetScheduledQuery") + } + + var r0 *cloudwatchlogs.GetScheduledQueryOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.GetScheduledQueryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetScheduledQueryOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.GetScheduledQueryInput, ...func(*cloudwatchlogs.Options)) *cloudwatchlogs.GetScheduledQueryOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudwatchlogs.GetScheduledQueryOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudwatchlogs.GetScheduledQueryInput, ...func(*cloudwatchlogs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudWatchLogs_GetScheduledQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetScheduledQuery' +type CloudWatchLogs_GetScheduledQuery_Call struct { + *mock.Call +} + +// GetScheduledQuery is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudwatchlogs.GetScheduledQueryInput +// - optFns ...func(*cloudwatchlogs.Options) +func (_e *CloudWatchLogs_Expecter) GetScheduledQuery(ctx interface{}, params interface{}, optFns ...interface{}) *CloudWatchLogs_GetScheduledQuery_Call { + return &CloudWatchLogs_GetScheduledQuery_Call{Call: _e.mock.On("GetScheduledQuery", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudWatchLogs_GetScheduledQuery_Call) Run(run func(ctx context.Context, params *cloudwatchlogs.GetScheduledQueryInput, optFns ...func(*cloudwatchlogs.Options))) *CloudWatchLogs_GetScheduledQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudwatchlogs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudwatchlogs.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudwatchlogs.GetScheduledQueryInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudWatchLogs_GetScheduledQuery_Call) Return(_a0 *cloudwatchlogs.GetScheduledQueryOutput, _a1 error) *CloudWatchLogs_GetScheduledQuery_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudWatchLogs_GetScheduledQuery_Call) RunAndReturn(run func(context.Context, *cloudwatchlogs.GetScheduledQueryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetScheduledQueryOutput, error)) *CloudWatchLogs_GetScheduledQuery_Call { + _c.Call.Return(run) + return _c +} + +// GetScheduledQueryHistory provides a mock function with given fields: ctx, params, optFns +func (_m *CloudWatchLogs) GetScheduledQueryHistory(ctx context.Context, params *cloudwatchlogs.GetScheduledQueryHistoryInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetScheduledQueryHistoryOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetScheduledQueryHistory") + } + + var r0 *cloudwatchlogs.GetScheduledQueryHistoryOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.GetScheduledQueryHistoryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetScheduledQueryHistoryOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.GetScheduledQueryHistoryInput, ...func(*cloudwatchlogs.Options)) *cloudwatchlogs.GetScheduledQueryHistoryOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudwatchlogs.GetScheduledQueryHistoryOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudwatchlogs.GetScheduledQueryHistoryInput, ...func(*cloudwatchlogs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudWatchLogs_GetScheduledQueryHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetScheduledQueryHistory' +type CloudWatchLogs_GetScheduledQueryHistory_Call struct { + *mock.Call +} + +// GetScheduledQueryHistory is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudwatchlogs.GetScheduledQueryHistoryInput +// - optFns ...func(*cloudwatchlogs.Options) +func (_e *CloudWatchLogs_Expecter) GetScheduledQueryHistory(ctx interface{}, params interface{}, optFns ...interface{}) *CloudWatchLogs_GetScheduledQueryHistory_Call { + return &CloudWatchLogs_GetScheduledQueryHistory_Call{Call: _e.mock.On("GetScheduledQueryHistory", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudWatchLogs_GetScheduledQueryHistory_Call) Run(run func(ctx context.Context, params *cloudwatchlogs.GetScheduledQueryHistoryInput, optFns ...func(*cloudwatchlogs.Options))) *CloudWatchLogs_GetScheduledQueryHistory_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudwatchlogs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudwatchlogs.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudwatchlogs.GetScheduledQueryHistoryInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudWatchLogs_GetScheduledQueryHistory_Call) Return(_a0 *cloudwatchlogs.GetScheduledQueryHistoryOutput, _a1 error) *CloudWatchLogs_GetScheduledQueryHistory_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudWatchLogs_GetScheduledQueryHistory_Call) RunAndReturn(run func(context.Context, *cloudwatchlogs.GetScheduledQueryHistoryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetScheduledQueryHistoryOutput, error)) *CloudWatchLogs_GetScheduledQueryHistory_Call { + _c.Call.Return(run) + return _c +} + // GetTransformer provides a mock function with given fields: ctx, params, optFns func (_m *CloudWatchLogs) GetTransformer(ctx context.Context, params *cloudwatchlogs.GetTransformerInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetTransformerOutput, error) { _va := make([]interface{}, len(optFns)) @@ -4537,6 +4833,80 @@ func (_c *CloudWatchLogs_ListLogGroupsForQuery_Call) RunAndReturn(run func(conte return _c } +// ListScheduledQueries provides a mock function with given fields: ctx, params, optFns +func (_m *CloudWatchLogs) ListScheduledQueries(ctx context.Context, params *cloudwatchlogs.ListScheduledQueriesInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.ListScheduledQueriesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListScheduledQueries") + } + + var r0 *cloudwatchlogs.ListScheduledQueriesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.ListScheduledQueriesInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.ListScheduledQueriesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.ListScheduledQueriesInput, ...func(*cloudwatchlogs.Options)) *cloudwatchlogs.ListScheduledQueriesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudwatchlogs.ListScheduledQueriesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudwatchlogs.ListScheduledQueriesInput, ...func(*cloudwatchlogs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudWatchLogs_ListScheduledQueries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListScheduledQueries' +type CloudWatchLogs_ListScheduledQueries_Call struct { + *mock.Call +} + +// ListScheduledQueries is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudwatchlogs.ListScheduledQueriesInput +// - optFns ...func(*cloudwatchlogs.Options) +func (_e *CloudWatchLogs_Expecter) ListScheduledQueries(ctx interface{}, params interface{}, optFns ...interface{}) *CloudWatchLogs_ListScheduledQueries_Call { + return &CloudWatchLogs_ListScheduledQueries_Call{Call: _e.mock.On("ListScheduledQueries", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudWatchLogs_ListScheduledQueries_Call) Run(run func(ctx context.Context, params *cloudwatchlogs.ListScheduledQueriesInput, optFns ...func(*cloudwatchlogs.Options))) *CloudWatchLogs_ListScheduledQueries_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudwatchlogs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudwatchlogs.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudwatchlogs.ListScheduledQueriesInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudWatchLogs_ListScheduledQueries_Call) Return(_a0 *cloudwatchlogs.ListScheduledQueriesOutput, _a1 error) *CloudWatchLogs_ListScheduledQueries_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudWatchLogs_ListScheduledQueries_Call) RunAndReturn(run func(context.Context, *cloudwatchlogs.ListScheduledQueriesInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.ListScheduledQueriesOutput, error)) *CloudWatchLogs_ListScheduledQueries_Call { + _c.Call.Return(run) + return _c +} + // ListTagsForResource provides a mock function with given fields: ctx, params, optFns func (_m *CloudWatchLogs) ListTagsForResource(ctx context.Context, params *cloudwatchlogs.ListTagsForResourceInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.ListTagsForResourceOutput, error) { _va := make([]interface{}, len(optFns)) @@ -6802,6 +7172,80 @@ func (_c *CloudWatchLogs_UpdateLogAnomalyDetector_Call) RunAndReturn(run func(co return _c } +// UpdateScheduledQuery provides a mock function with given fields: ctx, params, optFns +func (_m *CloudWatchLogs) UpdateScheduledQuery(ctx context.Context, params *cloudwatchlogs.UpdateScheduledQueryInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.UpdateScheduledQueryOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateScheduledQuery") + } + + var r0 *cloudwatchlogs.UpdateScheduledQueryOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.UpdateScheduledQueryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.UpdateScheduledQueryOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *cloudwatchlogs.UpdateScheduledQueryInput, ...func(*cloudwatchlogs.Options)) *cloudwatchlogs.UpdateScheduledQueryOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudwatchlogs.UpdateScheduledQueryOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *cloudwatchlogs.UpdateScheduledQueryInput, ...func(*cloudwatchlogs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CloudWatchLogs_UpdateScheduledQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateScheduledQuery' +type CloudWatchLogs_UpdateScheduledQuery_Call struct { + *mock.Call +} + +// UpdateScheduledQuery is a helper method to define mock.On call +// - ctx context.Context +// - params *cloudwatchlogs.UpdateScheduledQueryInput +// - optFns ...func(*cloudwatchlogs.Options) +func (_e *CloudWatchLogs_Expecter) UpdateScheduledQuery(ctx interface{}, params interface{}, optFns ...interface{}) *CloudWatchLogs_UpdateScheduledQuery_Call { + return &CloudWatchLogs_UpdateScheduledQuery_Call{Call: _e.mock.On("UpdateScheduledQuery", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *CloudWatchLogs_UpdateScheduledQuery_Call) Run(run func(ctx context.Context, params *cloudwatchlogs.UpdateScheduledQueryInput, optFns ...func(*cloudwatchlogs.Options))) *CloudWatchLogs_UpdateScheduledQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*cloudwatchlogs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*cloudwatchlogs.Options)) + } + } + run(args[0].(context.Context), args[1].(*cloudwatchlogs.UpdateScheduledQueryInput), variadicArgs...) + }) + return _c +} + +func (_c *CloudWatchLogs_UpdateScheduledQuery_Call) Return(_a0 *cloudwatchlogs.UpdateScheduledQueryOutput, _a1 error) *CloudWatchLogs_UpdateScheduledQuery_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *CloudWatchLogs_UpdateScheduledQuery_Call) RunAndReturn(run func(context.Context, *cloudwatchlogs.UpdateScheduledQueryInput, ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.UpdateScheduledQueryOutput, error)) *CloudWatchLogs_UpdateScheduledQuery_Call { + _c.Call.Return(run) + return _c +} + // NewCloudWatchLogs creates a new instance of CloudWatchLogs. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. func NewCloudWatchLogs(t interface { diff --git a/pkg/eks/mocksv2/EC2.go b/pkg/eks/mocksv2/EC2.go index 79e7d54476..912ff2f6d9 100644 --- a/pkg/eks/mocksv2/EC2.go +++ b/pkg/eks/mocksv2/EC2.go @@ -6312,6 +6312,80 @@ func (_c *EC2_CreateInternetGateway_Call) RunAndReturn(run func(context.Context, return _c } +// CreateInterruptibleCapacityReservationAllocation provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) CreateInterruptibleCapacityReservationAllocation(ctx context.Context, params *ec2.CreateInterruptibleCapacityReservationAllocationInput, optFns ...func(*ec2.Options)) (*ec2.CreateInterruptibleCapacityReservationAllocationOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateInterruptibleCapacityReservationAllocation") + } + + var r0 *ec2.CreateInterruptibleCapacityReservationAllocationOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) (*ec2.CreateInterruptibleCapacityReservationAllocationOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) *ec2.CreateInterruptibleCapacityReservationAllocationOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.CreateInterruptibleCapacityReservationAllocationOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_CreateInterruptibleCapacityReservationAllocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInterruptibleCapacityReservationAllocation' +type EC2_CreateInterruptibleCapacityReservationAllocation_Call struct { + *mock.Call +} + +// CreateInterruptibleCapacityReservationAllocation is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.CreateInterruptibleCapacityReservationAllocationInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) CreateInterruptibleCapacityReservationAllocation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateInterruptibleCapacityReservationAllocation_Call { + return &EC2_CreateInterruptibleCapacityReservationAllocation_Call{Call: _e.mock.On("CreateInterruptibleCapacityReservationAllocation", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_CreateInterruptibleCapacityReservationAllocation_Call) Run(run func(ctx context.Context, params *ec2.CreateInterruptibleCapacityReservationAllocationInput, optFns ...func(*ec2.Options))) *EC2_CreateInterruptibleCapacityReservationAllocation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.CreateInterruptibleCapacityReservationAllocationInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_CreateInterruptibleCapacityReservationAllocation_Call) Return(_a0 *ec2.CreateInterruptibleCapacityReservationAllocationOutput, _a1 error) *EC2_CreateInterruptibleCapacityReservationAllocation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_CreateInterruptibleCapacityReservationAllocation_Call) RunAndReturn(run func(context.Context, *ec2.CreateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) (*ec2.CreateInterruptibleCapacityReservationAllocationOutput, error)) *EC2_CreateInterruptibleCapacityReservationAllocation_Call { + _c.Call.Return(run) + return _c +} + // CreateIpam provides a mock function with given fields: ctx, params, optFns func (_m *EC2) CreateIpam(ctx context.Context, params *ec2.CreateIpamInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamOutput, error) { _va := make([]interface{}, len(optFns)) @@ -6460,6 +6534,80 @@ func (_c *EC2_CreateIpamExternalResourceVerificationToken_Call) RunAndReturn(run return _c } +// CreateIpamPolicy provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) CreateIpamPolicy(ctx context.Context, params *ec2.CreateIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamPolicyOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateIpamPolicy") + } + + var r0 *ec2.CreateIpamPolicyOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPolicyInput, ...func(*ec2.Options)) (*ec2.CreateIpamPolicyOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPolicyInput, ...func(*ec2.Options)) *ec2.CreateIpamPolicyOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.CreateIpamPolicyOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamPolicyInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_CreateIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpamPolicy' +type EC2_CreateIpamPolicy_Call struct { + *mock.Call +} + +// CreateIpamPolicy is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.CreateIpamPolicyInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) CreateIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpamPolicy_Call { + return &EC2_CreateIpamPolicy_Call{Call: _e.mock.On("CreateIpamPolicy", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_CreateIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_CreateIpamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.CreateIpamPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_CreateIpamPolicy_Call) Return(_a0 *ec2.CreateIpamPolicyOutput, _a1 error) *EC2_CreateIpamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_CreateIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamPolicyInput, ...func(*ec2.Options)) (*ec2.CreateIpamPolicyOutput, error)) *EC2_CreateIpamPolicy_Call { + _c.Call.Return(run) + return _c +} + // CreateIpamPool provides a mock function with given fields: ctx, params, optFns func (_m *EC2) CreateIpamPool(ctx context.Context, params *ec2.CreateIpamPoolInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamPoolOutput, error) { _va := make([]interface{}, len(optFns)) @@ -10012,6 +10160,154 @@ func (_c *EC2_CreateTransitGatewayConnectPeer_Call) RunAndReturn(run func(contex return _c } +// CreateTransitGatewayMeteringPolicy provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) CreateTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateTransitGatewayMeteringPolicy") + } + + var r0 *ec2.CreateTransitGatewayMeteringPolicyOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayMeteringPolicyOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.CreateTransitGatewayMeteringPolicyOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_CreateTransitGatewayMeteringPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayMeteringPolicy' +type EC2_CreateTransitGatewayMeteringPolicy_Call struct { + *mock.Call +} + +// CreateTransitGatewayMeteringPolicy is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.CreateTransitGatewayMeteringPolicyInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) CreateTransitGatewayMeteringPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayMeteringPolicy_Call { + return &EC2_CreateTransitGatewayMeteringPolicy_Call{Call: _e.mock.On("CreateTransitGatewayMeteringPolicy", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_CreateTransitGatewayMeteringPolicy_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayMeteringPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayMeteringPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_CreateTransitGatewayMeteringPolicy_Call) Return(_a0 *ec2.CreateTransitGatewayMeteringPolicyOutput, _a1 error) *EC2_CreateTransitGatewayMeteringPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_CreateTransitGatewayMeteringPolicy_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyOutput, error)) *EC2_CreateTransitGatewayMeteringPolicy_Call { + _c.Call.Return(run) + return _c +} + +// CreateTransitGatewayMeteringPolicyEntry provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) CreateTransitGatewayMeteringPolicyEntry(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyEntryInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyEntryOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateTransitGatewayMeteringPolicyEntry") + } + + var r0 *ec2.CreateTransitGatewayMeteringPolicyEntryOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyEntryOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayMeteringPolicyEntryOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.CreateTransitGatewayMeteringPolicyEntryOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_CreateTransitGatewayMeteringPolicyEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayMeteringPolicyEntry' +type EC2_CreateTransitGatewayMeteringPolicyEntry_Call struct { + *mock.Call +} + +// CreateTransitGatewayMeteringPolicyEntry is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.CreateTransitGatewayMeteringPolicyEntryInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) CreateTransitGatewayMeteringPolicyEntry(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayMeteringPolicyEntry_Call { + return &EC2_CreateTransitGatewayMeteringPolicyEntry_Call{Call: _e.mock.On("CreateTransitGatewayMeteringPolicyEntry", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_CreateTransitGatewayMeteringPolicyEntry_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyEntryInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayMeteringPolicyEntry_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayMeteringPolicyEntryInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_CreateTransitGatewayMeteringPolicyEntry_Call) Return(_a0 *ec2.CreateTransitGatewayMeteringPolicyEntryOutput, _a1 error) *EC2_CreateTransitGatewayMeteringPolicyEntry_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_CreateTransitGatewayMeteringPolicyEntry_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyEntryOutput, error)) *EC2_CreateTransitGatewayMeteringPolicyEntry_Call { + _c.Call.Return(run) + return _c +} + // CreateTransitGatewayMulticastDomain provides a mock function with given fields: ctx, params, optFns func (_m *EC2) CreateTransitGatewayMulticastDomain(ctx context.Context, params *ec2.CreateTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { _va := make([]interface{}, len(optFns)) @@ -11122,6 +11418,80 @@ func (_c *EC2_CreateVpcBlockPublicAccessExclusion_Call) RunAndReturn(run func(co return _c } +// CreateVpcEncryptionControl provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) CreateVpcEncryptionControl(ctx context.Context, params *ec2.CreateVpcEncryptionControlInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcEncryptionControlOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateVpcEncryptionControl") + } + + var r0 *ec2.CreateVpcEncryptionControlOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.CreateVpcEncryptionControlOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEncryptionControlInput, ...func(*ec2.Options)) *ec2.CreateVpcEncryptionControlOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.CreateVpcEncryptionControlOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpcEncryptionControlInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_CreateVpcEncryptionControl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpcEncryptionControl' +type EC2_CreateVpcEncryptionControl_Call struct { + *mock.Call +} + +// CreateVpcEncryptionControl is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.CreateVpcEncryptionControlInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) CreateVpcEncryptionControl(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpcEncryptionControl_Call { + return &EC2_CreateVpcEncryptionControl_Call{Call: _e.mock.On("CreateVpcEncryptionControl", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_CreateVpcEncryptionControl_Call) Run(run func(ctx context.Context, params *ec2.CreateVpcEncryptionControlInput, optFns ...func(*ec2.Options))) *EC2_CreateVpcEncryptionControl_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.CreateVpcEncryptionControlInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_CreateVpcEncryptionControl_Call) Return(_a0 *ec2.CreateVpcEncryptionControlOutput, _a1 error) *EC2_CreateVpcEncryptionControl_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_CreateVpcEncryptionControl_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.CreateVpcEncryptionControlOutput, error)) *EC2_CreateVpcEncryptionControl_Call { + _c.Call.Return(run) + return _c +} + // CreateVpcEndpoint provides a mock function with given fields: ctx, params, optFns func (_m *EC2) CreateVpcEndpoint(ctx context.Context, params *ec2.CreateVpcEndpointInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcEndpointOutput, error) { _va := make([]interface{}, len(optFns)) @@ -11418,6 +11788,80 @@ func (_c *EC2_CreateVpcPeeringConnection_Call) RunAndReturn(run func(context.Con return _c } +// CreateVpnConcentrator provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) CreateVpnConcentrator(ctx context.Context, params *ec2.CreateVpnConcentratorInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpnConcentratorOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateVpnConcentrator") + } + + var r0 *ec2.CreateVpnConcentratorOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConcentratorInput, ...func(*ec2.Options)) (*ec2.CreateVpnConcentratorOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConcentratorInput, ...func(*ec2.Options)) *ec2.CreateVpnConcentratorOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.CreateVpnConcentratorOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpnConcentratorInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_CreateVpnConcentrator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpnConcentrator' +type EC2_CreateVpnConcentrator_Call struct { + *mock.Call +} + +// CreateVpnConcentrator is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.CreateVpnConcentratorInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) CreateVpnConcentrator(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpnConcentrator_Call { + return &EC2_CreateVpnConcentrator_Call{Call: _e.mock.On("CreateVpnConcentrator", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_CreateVpnConcentrator_Call) Run(run func(ctx context.Context, params *ec2.CreateVpnConcentratorInput, optFns ...func(*ec2.Options))) *EC2_CreateVpnConcentrator_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.CreateVpnConcentratorInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_CreateVpnConcentrator_Call) Return(_a0 *ec2.CreateVpnConcentratorOutput, _a1 error) *EC2_CreateVpnConcentrator_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_CreateVpnConcentrator_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpnConcentratorInput, ...func(*ec2.Options)) (*ec2.CreateVpnConcentratorOutput, error)) *EC2_CreateVpnConcentrator_Call { + _c.Call.Return(run) + return _c +} + // CreateVpnConnection provides a mock function with given fields: ctx, params, optFns func (_m *EC2) CreateVpnConnection(ctx context.Context, params *ec2.CreateVpnConnectionInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpnConnectionOutput, error) { _va := make([]interface{}, len(optFns)) @@ -12972,6 +13416,80 @@ func (_c *EC2_DeleteIpamExternalResourceVerificationToken_Call) RunAndReturn(run return _c } +// DeleteIpamPolicy provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DeleteIpamPolicy(ctx context.Context, params *ec2.DeleteIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamPolicyOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteIpamPolicy") + } + + var r0 *ec2.DeleteIpamPolicyOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPolicyInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPolicyOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPolicyInput, ...func(*ec2.Options)) *ec2.DeleteIpamPolicyOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DeleteIpamPolicyOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamPolicyInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DeleteIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpamPolicy' +type EC2_DeleteIpamPolicy_Call struct { + *mock.Call +} + +// DeleteIpamPolicy is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DeleteIpamPolicyInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DeleteIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpamPolicy_Call { + return &EC2_DeleteIpamPolicy_Call{Call: _e.mock.On("DeleteIpamPolicy", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DeleteIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DeleteIpamPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DeleteIpamPolicy_Call) Return(_a0 *ec2.DeleteIpamPolicyOutput, _a1 error) *EC2_DeleteIpamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DeleteIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamPolicyInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPolicyOutput, error)) *EC2_DeleteIpamPolicy_Call { + _c.Call.Return(run) + return _c +} + // DeleteIpamPool provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DeleteIpamPool(ctx context.Context, params *ec2.DeleteIpamPoolInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamPoolOutput, error) { _va := make([]interface{}, len(optFns)) @@ -16302,6 +16820,154 @@ func (_c *EC2_DeleteTransitGatewayConnectPeer_Call) RunAndReturn(run func(contex return _c } +// DeleteTransitGatewayMeteringPolicy provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DeleteTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteTransitGatewayMeteringPolicy") + } + + var r0 *ec2.DeleteTransitGatewayMeteringPolicyOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayMeteringPolicyOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DeleteTransitGatewayMeteringPolicyOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DeleteTransitGatewayMeteringPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayMeteringPolicy' +type EC2_DeleteTransitGatewayMeteringPolicy_Call struct { + *mock.Call +} + +// DeleteTransitGatewayMeteringPolicy is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DeleteTransitGatewayMeteringPolicyInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DeleteTransitGatewayMeteringPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayMeteringPolicy_Call { + return &EC2_DeleteTransitGatewayMeteringPolicy_Call{Call: _e.mock.On("DeleteTransitGatewayMeteringPolicy", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DeleteTransitGatewayMeteringPolicy_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayMeteringPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayMeteringPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DeleteTransitGatewayMeteringPolicy_Call) Return(_a0 *ec2.DeleteTransitGatewayMeteringPolicyOutput, _a1 error) *EC2_DeleteTransitGatewayMeteringPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DeleteTransitGatewayMeteringPolicy_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyOutput, error)) *EC2_DeleteTransitGatewayMeteringPolicy_Call { + _c.Call.Return(run) + return _c +} + +// DeleteTransitGatewayMeteringPolicyEntry provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DeleteTransitGatewayMeteringPolicyEntry(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteTransitGatewayMeteringPolicyEntry") + } + + var r0 *ec2.DeleteTransitGatewayMeteringPolicyEntryOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayMeteringPolicyEntryOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DeleteTransitGatewayMeteringPolicyEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayMeteringPolicyEntry' +type EC2_DeleteTransitGatewayMeteringPolicyEntry_Call struct { + *mock.Call +} + +// DeleteTransitGatewayMeteringPolicyEntry is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DeleteTransitGatewayMeteringPolicyEntryInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DeleteTransitGatewayMeteringPolicyEntry(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call { + return &EC2_DeleteTransitGatewayMeteringPolicyEntry_Call{Call: _e.mock.On("DeleteTransitGatewayMeteringPolicyEntry", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayMeteringPolicyEntryInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call) Return(_a0 *ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, _a1 error) *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, error)) *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call { + _c.Call.Return(run) + return _c +} + // DeleteTransitGatewayMulticastDomain provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DeleteTransitGatewayMulticastDomain(ctx context.Context, params *ec2.DeleteTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) { _va := make([]interface{}, len(optFns)) @@ -17412,6 +18078,80 @@ func (_c *EC2_DeleteVpcBlockPublicAccessExclusion_Call) RunAndReturn(run func(co return _c } +// DeleteVpcEncryptionControl provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DeleteVpcEncryptionControl(ctx context.Context, params *ec2.DeleteVpcEncryptionControlInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEncryptionControlOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteVpcEncryptionControl") + } + + var r0 *ec2.DeleteVpcEncryptionControlOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEncryptionControlOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEncryptionControlInput, ...func(*ec2.Options)) *ec2.DeleteVpcEncryptionControlOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DeleteVpcEncryptionControlOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpcEncryptionControlInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DeleteVpcEncryptionControl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpcEncryptionControl' +type EC2_DeleteVpcEncryptionControl_Call struct { + *mock.Call +} + +// DeleteVpcEncryptionControl is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DeleteVpcEncryptionControlInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DeleteVpcEncryptionControl(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpcEncryptionControl_Call { + return &EC2_DeleteVpcEncryptionControl_Call{Call: _e.mock.On("DeleteVpcEncryptionControl", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DeleteVpcEncryptionControl_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpcEncryptionControlInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpcEncryptionControl_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DeleteVpcEncryptionControlInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DeleteVpcEncryptionControl_Call) Return(_a0 *ec2.DeleteVpcEncryptionControlOutput, _a1 error) *EC2_DeleteVpcEncryptionControl_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DeleteVpcEncryptionControl_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEncryptionControlOutput, error)) *EC2_DeleteVpcEncryptionControl_Call { + _c.Call.Return(run) + return _c +} + // DeleteVpcEndpointConnectionNotifications provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DeleteVpcEndpointConnectionNotifications(ctx context.Context, params *ec2.DeleteVpcEndpointConnectionNotificationsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -17708,6 +18448,80 @@ func (_c *EC2_DeleteVpcPeeringConnection_Call) RunAndReturn(run func(context.Con return _c } +// DeleteVpnConcentrator provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DeleteVpnConcentrator(ctx context.Context, params *ec2.DeleteVpnConcentratorInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpnConcentratorOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteVpnConcentrator") + } + + var r0 *ec2.DeleteVpnConcentratorOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConcentratorInput, ...func(*ec2.Options)) (*ec2.DeleteVpnConcentratorOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConcentratorInput, ...func(*ec2.Options)) *ec2.DeleteVpnConcentratorOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DeleteVpnConcentratorOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpnConcentratorInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DeleteVpnConcentrator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpnConcentrator' +type EC2_DeleteVpnConcentrator_Call struct { + *mock.Call +} + +// DeleteVpnConcentrator is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DeleteVpnConcentratorInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DeleteVpnConcentrator(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpnConcentrator_Call { + return &EC2_DeleteVpnConcentrator_Call{Call: _e.mock.On("DeleteVpnConcentrator", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DeleteVpnConcentrator_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpnConcentratorInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpnConcentrator_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DeleteVpnConcentratorInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DeleteVpnConcentrator_Call) Return(_a0 *ec2.DeleteVpnConcentratorOutput, _a1 error) *EC2_DeleteVpnConcentrator_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DeleteVpnConcentrator_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpnConcentratorInput, ...func(*ec2.Options)) (*ec2.DeleteVpnConcentratorOutput, error)) *EC2_DeleteVpnConcentrator_Call { + _c.Call.Return(run) + return _c +} + // DeleteVpnConnection provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DeleteVpnConnection(ctx context.Context, params *ec2.DeleteVpnConnectionInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpnConnectionOutput, error) { _va := make([]interface{}, len(optFns)) @@ -23110,6 +23924,154 @@ func (_c *EC2_DescribeInstanceImageMetadata_Call) RunAndReturn(run func(context. return _c } +// DescribeInstanceSqlHaHistoryStates provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DescribeInstanceSqlHaHistoryStates(ctx context.Context, params *ec2.DescribeInstanceSqlHaHistoryStatesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaHistoryStatesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeInstanceSqlHaHistoryStates") + } + + var r0 *ec2.DescribeInstanceSqlHaHistoryStatesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceSqlHaHistoryStatesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaHistoryStatesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceSqlHaHistoryStatesInput, ...func(*ec2.Options)) *ec2.DescribeInstanceSqlHaHistoryStatesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DescribeInstanceSqlHaHistoryStatesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceSqlHaHistoryStatesInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DescribeInstanceSqlHaHistoryStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceSqlHaHistoryStates' +type EC2_DescribeInstanceSqlHaHistoryStates_Call struct { + *mock.Call +} + +// DescribeInstanceSqlHaHistoryStates is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DescribeInstanceSqlHaHistoryStatesInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DescribeInstanceSqlHaHistoryStates(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceSqlHaHistoryStates_Call { + return &EC2_DescribeInstanceSqlHaHistoryStates_Call{Call: _e.mock.On("DescribeInstanceSqlHaHistoryStates", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DescribeInstanceSqlHaHistoryStates_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceSqlHaHistoryStatesInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceSqlHaHistoryStates_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceSqlHaHistoryStatesInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DescribeInstanceSqlHaHistoryStates_Call) Return(_a0 *ec2.DescribeInstanceSqlHaHistoryStatesOutput, _a1 error) *EC2_DescribeInstanceSqlHaHistoryStates_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DescribeInstanceSqlHaHistoryStates_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceSqlHaHistoryStatesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaHistoryStatesOutput, error)) *EC2_DescribeInstanceSqlHaHistoryStates_Call { + _c.Call.Return(run) + return _c +} + +// DescribeInstanceSqlHaStates provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DescribeInstanceSqlHaStates(ctx context.Context, params *ec2.DescribeInstanceSqlHaStatesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaStatesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeInstanceSqlHaStates") + } + + var r0 *ec2.DescribeInstanceSqlHaStatesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceSqlHaStatesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaStatesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceSqlHaStatesInput, ...func(*ec2.Options)) *ec2.DescribeInstanceSqlHaStatesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DescribeInstanceSqlHaStatesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceSqlHaStatesInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DescribeInstanceSqlHaStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceSqlHaStates' +type EC2_DescribeInstanceSqlHaStates_Call struct { + *mock.Call +} + +// DescribeInstanceSqlHaStates is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DescribeInstanceSqlHaStatesInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DescribeInstanceSqlHaStates(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceSqlHaStates_Call { + return &EC2_DescribeInstanceSqlHaStates_Call{Call: _e.mock.On("DescribeInstanceSqlHaStates", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DescribeInstanceSqlHaStates_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceSqlHaStatesInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceSqlHaStates_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceSqlHaStatesInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DescribeInstanceSqlHaStates_Call) Return(_a0 *ec2.DescribeInstanceSqlHaStatesOutput, _a1 error) *EC2_DescribeInstanceSqlHaStates_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DescribeInstanceSqlHaStates_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceSqlHaStatesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaStatesOutput, error)) *EC2_DescribeInstanceSqlHaStates_Call { + _c.Call.Return(run) + return _c +} + // DescribeInstanceStatus provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DescribeInstanceStatus(ctx context.Context, params *ec2.DescribeInstanceStatusInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceStatusOutput, error) { _va := make([]interface{}, len(optFns)) @@ -23702,6 +24664,80 @@ func (_c *EC2_DescribeIpamExternalResourceVerificationTokens_Call) RunAndReturn( return _c } +// DescribeIpamPolicies provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DescribeIpamPolicies(ctx context.Context, params *ec2.DescribeIpamPoliciesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamPoliciesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeIpamPolicies") + } + + var r0 *ec2.DescribeIpamPoliciesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPoliciesInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPoliciesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPoliciesInput, ...func(*ec2.Options)) *ec2.DescribeIpamPoliciesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DescribeIpamPoliciesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamPoliciesInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DescribeIpamPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamPolicies' +type EC2_DescribeIpamPolicies_Call struct { + *mock.Call +} + +// DescribeIpamPolicies is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DescribeIpamPoliciesInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DescribeIpamPolicies(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamPolicies_Call { + return &EC2_DescribeIpamPolicies_Call{Call: _e.mock.On("DescribeIpamPolicies", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DescribeIpamPolicies_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamPoliciesInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamPolicies_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DescribeIpamPoliciesInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DescribeIpamPolicies_Call) Return(_a0 *ec2.DescribeIpamPoliciesOutput, _a1 error) *EC2_DescribeIpamPolicies_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DescribeIpamPolicies_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamPoliciesInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPoliciesOutput, error)) *EC2_DescribeIpamPolicies_Call { + _c.Call.Return(run) + return _c +} + // DescribeIpamPools provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DescribeIpamPools(ctx context.Context, params *ec2.DescribeIpamPoolsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamPoolsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -29104,6 +30140,80 @@ func (_c *EC2_DescribeTransitGatewayConnects_Call) RunAndReturn(run func(context return _c } +// DescribeTransitGatewayMeteringPolicies provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DescribeTransitGatewayMeteringPolicies(ctx context.Context, params *ec2.DescribeTransitGatewayMeteringPoliciesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMeteringPoliciesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeTransitGatewayMeteringPolicies") + } + + var r0 *ec2.DescribeTransitGatewayMeteringPoliciesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayMeteringPoliciesInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMeteringPoliciesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayMeteringPoliciesInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayMeteringPoliciesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DescribeTransitGatewayMeteringPoliciesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayMeteringPoliciesInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DescribeTransitGatewayMeteringPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayMeteringPolicies' +type EC2_DescribeTransitGatewayMeteringPolicies_Call struct { + *mock.Call +} + +// DescribeTransitGatewayMeteringPolicies is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DescribeTransitGatewayMeteringPoliciesInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DescribeTransitGatewayMeteringPolicies(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayMeteringPolicies_Call { + return &EC2_DescribeTransitGatewayMeteringPolicies_Call{Call: _e.mock.On("DescribeTransitGatewayMeteringPolicies", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DescribeTransitGatewayMeteringPolicies_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayMeteringPoliciesInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayMeteringPolicies_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayMeteringPoliciesInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DescribeTransitGatewayMeteringPolicies_Call) Return(_a0 *ec2.DescribeTransitGatewayMeteringPoliciesOutput, _a1 error) *EC2_DescribeTransitGatewayMeteringPolicies_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DescribeTransitGatewayMeteringPolicies_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayMeteringPoliciesInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMeteringPoliciesOutput, error)) *EC2_DescribeTransitGatewayMeteringPolicies_Call { + _c.Call.Return(run) + return _c +} + // DescribeTransitGatewayMulticastDomains provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DescribeTransitGatewayMulticastDomains(ctx context.Context, params *ec2.DescribeTransitGatewayMulticastDomainsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -30732,6 +31842,80 @@ func (_c *EC2_DescribeVpcClassicLinkDnsSupport_Call) RunAndReturn(run func(conte return _c } +// DescribeVpcEncryptionControls provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DescribeVpcEncryptionControls(ctx context.Context, params *ec2.DescribeVpcEncryptionControlsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEncryptionControlsOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeVpcEncryptionControls") + } + + var r0 *ec2.DescribeVpcEncryptionControlsOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEncryptionControlsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEncryptionControlsOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEncryptionControlsInput, ...func(*ec2.Options)) *ec2.DescribeVpcEncryptionControlsOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DescribeVpcEncryptionControlsOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEncryptionControlsInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DescribeVpcEncryptionControls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEncryptionControls' +type EC2_DescribeVpcEncryptionControls_Call struct { + *mock.Call +} + +// DescribeVpcEncryptionControls is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DescribeVpcEncryptionControlsInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DescribeVpcEncryptionControls(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEncryptionControls_Call { + return &EC2_DescribeVpcEncryptionControls_Call{Call: _e.mock.On("DescribeVpcEncryptionControls", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DescribeVpcEncryptionControls_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEncryptionControlsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEncryptionControls_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEncryptionControlsInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DescribeVpcEncryptionControls_Call) Return(_a0 *ec2.DescribeVpcEncryptionControlsOutput, _a1 error) *EC2_DescribeVpcEncryptionControls_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DescribeVpcEncryptionControls_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEncryptionControlsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEncryptionControlsOutput, error)) *EC2_DescribeVpcEncryptionControls_Call { + _c.Call.Return(run) + return _c +} + // DescribeVpcEndpointAssociations provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DescribeVpcEndpointAssociations(ctx context.Context, params *ec2.DescribeVpcEndpointAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointAssociationsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -31398,6 +32582,80 @@ func (_c *EC2_DescribeVpcs_Call) RunAndReturn(run func(context.Context, *ec2.Des return _c } +// DescribeVpnConcentrators provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DescribeVpnConcentrators(ctx context.Context, params *ec2.DescribeVpnConcentratorsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpnConcentratorsOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DescribeVpnConcentrators") + } + + var r0 *ec2.DescribeVpnConcentratorsOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnConcentratorsInput, ...func(*ec2.Options)) (*ec2.DescribeVpnConcentratorsOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnConcentratorsInput, ...func(*ec2.Options)) *ec2.DescribeVpnConcentratorsOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DescribeVpnConcentratorsOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpnConcentratorsInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DescribeVpnConcentrators_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpnConcentrators' +type EC2_DescribeVpnConcentrators_Call struct { + *mock.Call +} + +// DescribeVpnConcentrators is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DescribeVpnConcentratorsInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DescribeVpnConcentrators(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpnConcentrators_Call { + return &EC2_DescribeVpnConcentrators_Call{Call: _e.mock.On("DescribeVpnConcentrators", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DescribeVpnConcentrators_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpnConcentratorsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpnConcentrators_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DescribeVpnConcentratorsInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DescribeVpnConcentrators_Call) Return(_a0 *ec2.DescribeVpnConcentratorsOutput, _a1 error) *EC2_DescribeVpnConcentrators_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DescribeVpnConcentrators_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpnConcentratorsInput, ...func(*ec2.Options)) (*ec2.DescribeVpnConcentratorsOutput, error)) *EC2_DescribeVpnConcentrators_Call { + _c.Call.Return(run) + return _c +} + // DescribeVpnConnections provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DescribeVpnConnections(ctx context.Context, params *ec2.DescribeVpnConnectionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpnConnectionsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -32804,6 +34062,80 @@ func (_c *EC2_DisableImageDeregistrationProtection_Call) RunAndReturn(run func(c return _c } +// DisableInstanceSqlHaStandbyDetections provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DisableInstanceSqlHaStandbyDetections(ctx context.Context, params *ec2.DisableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*ec2.Options)) (*ec2.DisableInstanceSqlHaStandbyDetectionsOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DisableInstanceSqlHaStandbyDetections") + } + + var r0 *ec2.DisableInstanceSqlHaStandbyDetectionsOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) (*ec2.DisableInstanceSqlHaStandbyDetectionsOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) *ec2.DisableInstanceSqlHaStandbyDetectionsOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DisableInstanceSqlHaStandbyDetectionsOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DisableInstanceSqlHaStandbyDetections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableInstanceSqlHaStandbyDetections' +type EC2_DisableInstanceSqlHaStandbyDetections_Call struct { + *mock.Call +} + +// DisableInstanceSqlHaStandbyDetections is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DisableInstanceSqlHaStandbyDetectionsInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DisableInstanceSqlHaStandbyDetections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableInstanceSqlHaStandbyDetections_Call { + return &EC2_DisableInstanceSqlHaStandbyDetections_Call{Call: _e.mock.On("DisableInstanceSqlHaStandbyDetections", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DisableInstanceSqlHaStandbyDetections_Call) Run(run func(ctx context.Context, params *ec2.DisableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*ec2.Options))) *EC2_DisableInstanceSqlHaStandbyDetections_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DisableInstanceSqlHaStandbyDetectionsInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DisableInstanceSqlHaStandbyDetections_Call) Return(_a0 *ec2.DisableInstanceSqlHaStandbyDetectionsOutput, _a1 error) *EC2_DisableInstanceSqlHaStandbyDetections_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DisableInstanceSqlHaStandbyDetections_Call) RunAndReturn(run func(context.Context, *ec2.DisableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) (*ec2.DisableInstanceSqlHaStandbyDetectionsOutput, error)) *EC2_DisableInstanceSqlHaStandbyDetections_Call { + _c.Call.Return(run) + return _c +} + // DisableIpamOrganizationAdminAccount provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DisableIpamOrganizationAdminAccount(ctx context.Context, params *ec2.DisableIpamOrganizationAdminAccountInput, optFns ...func(*ec2.Options)) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) { _va := make([]interface{}, len(optFns)) @@ -32878,6 +34210,80 @@ func (_c *EC2_DisableIpamOrganizationAdminAccount_Call) RunAndReturn(run func(co return _c } +// DisableIpamPolicy provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) DisableIpamPolicy(ctx context.Context, params *ec2.DisableIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.DisableIpamPolicyOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DisableIpamPolicy") + } + + var r0 *ec2.DisableIpamPolicyOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableIpamPolicyInput, ...func(*ec2.Options)) (*ec2.DisableIpamPolicyOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableIpamPolicyInput, ...func(*ec2.Options)) *ec2.DisableIpamPolicyOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.DisableIpamPolicyOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableIpamPolicyInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_DisableIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableIpamPolicy' +type EC2_DisableIpamPolicy_Call struct { + *mock.Call +} + +// DisableIpamPolicy is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.DisableIpamPolicyInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) DisableIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableIpamPolicy_Call { + return &EC2_DisableIpamPolicy_Call{Call: _e.mock.On("DisableIpamPolicy", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_DisableIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.DisableIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_DisableIpamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.DisableIpamPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_DisableIpamPolicy_Call) Return(_a0 *ec2.DisableIpamPolicyOutput, _a1 error) *EC2_DisableIpamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_DisableIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.DisableIpamPolicyInput, ...func(*ec2.Options)) (*ec2.DisableIpamPolicyOutput, error)) *EC2_DisableIpamPolicy_Call { + _c.Call.Return(run) + return _c +} + // DisableRouteServerPropagation provides a mock function with given fields: ctx, params, optFns func (_m *EC2) DisableRouteServerPropagation(ctx context.Context, params *ec2.DisableRouteServerPropagationInput, optFns ...func(*ec2.Options)) (*ec2.DisableRouteServerPropagationOutput, error) { _va := make([]interface{}, len(optFns)) @@ -35542,6 +36948,80 @@ func (_c *EC2_EnableImageDeregistrationProtection_Call) RunAndReturn(run func(co return _c } +// EnableInstanceSqlHaStandbyDetections provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) EnableInstanceSqlHaStandbyDetections(ctx context.Context, params *ec2.EnableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*ec2.Options)) (*ec2.EnableInstanceSqlHaStandbyDetectionsOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for EnableInstanceSqlHaStandbyDetections") + } + + var r0 *ec2.EnableInstanceSqlHaStandbyDetectionsOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) (*ec2.EnableInstanceSqlHaStandbyDetectionsOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) *ec2.EnableInstanceSqlHaStandbyDetectionsOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.EnableInstanceSqlHaStandbyDetectionsOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_EnableInstanceSqlHaStandbyDetections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableInstanceSqlHaStandbyDetections' +type EC2_EnableInstanceSqlHaStandbyDetections_Call struct { + *mock.Call +} + +// EnableInstanceSqlHaStandbyDetections is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.EnableInstanceSqlHaStandbyDetectionsInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) EnableInstanceSqlHaStandbyDetections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableInstanceSqlHaStandbyDetections_Call { + return &EC2_EnableInstanceSqlHaStandbyDetections_Call{Call: _e.mock.On("EnableInstanceSqlHaStandbyDetections", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_EnableInstanceSqlHaStandbyDetections_Call) Run(run func(ctx context.Context, params *ec2.EnableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*ec2.Options))) *EC2_EnableInstanceSqlHaStandbyDetections_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.EnableInstanceSqlHaStandbyDetectionsInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_EnableInstanceSqlHaStandbyDetections_Call) Return(_a0 *ec2.EnableInstanceSqlHaStandbyDetectionsOutput, _a1 error) *EC2_EnableInstanceSqlHaStandbyDetections_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_EnableInstanceSqlHaStandbyDetections_Call) RunAndReturn(run func(context.Context, *ec2.EnableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) (*ec2.EnableInstanceSqlHaStandbyDetectionsOutput, error)) *EC2_EnableInstanceSqlHaStandbyDetections_Call { + _c.Call.Return(run) + return _c +} + // EnableIpamOrganizationAdminAccount provides a mock function with given fields: ctx, params, optFns func (_m *EC2) EnableIpamOrganizationAdminAccount(ctx context.Context, params *ec2.EnableIpamOrganizationAdminAccountInput, optFns ...func(*ec2.Options)) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) { _va := make([]interface{}, len(optFns)) @@ -35616,6 +37096,80 @@ func (_c *EC2_EnableIpamOrganizationAdminAccount_Call) RunAndReturn(run func(con return _c } +// EnableIpamPolicy provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) EnableIpamPolicy(ctx context.Context, params *ec2.EnableIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.EnableIpamPolicyOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for EnableIpamPolicy") + } + + var r0 *ec2.EnableIpamPolicyOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableIpamPolicyInput, ...func(*ec2.Options)) (*ec2.EnableIpamPolicyOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableIpamPolicyInput, ...func(*ec2.Options)) *ec2.EnableIpamPolicyOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.EnableIpamPolicyOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableIpamPolicyInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_EnableIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableIpamPolicy' +type EC2_EnableIpamPolicy_Call struct { + *mock.Call +} + +// EnableIpamPolicy is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.EnableIpamPolicyInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) EnableIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableIpamPolicy_Call { + return &EC2_EnableIpamPolicy_Call{Call: _e.mock.On("EnableIpamPolicy", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_EnableIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.EnableIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_EnableIpamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.EnableIpamPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_EnableIpamPolicy_Call) Return(_a0 *ec2.EnableIpamPolicyOutput, _a1 error) *EC2_EnableIpamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_EnableIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.EnableIpamPolicyInput, ...func(*ec2.Options)) (*ec2.EnableIpamPolicyOutput, error)) *EC2_EnableIpamPolicy_Call { + _c.Call.Return(run) + return _c +} + // EnableReachabilityAnalyzerOrganizationSharing provides a mock function with given fields: ctx, params, optFns func (_m *EC2) EnableReachabilityAnalyzerOrganizationSharing(ctx context.Context, params *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, optFns ...func(*ec2.Options)) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error) { _va := make([]interface{}, len(optFns)) @@ -37836,6 +39390,80 @@ func (_c *EC2_GetEbsEncryptionByDefault_Call) RunAndReturn(run func(context.Cont return _c } +// GetEnabledIpamPolicy provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) GetEnabledIpamPolicy(ctx context.Context, params *ec2.GetEnabledIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.GetEnabledIpamPolicyOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetEnabledIpamPolicy") + } + + var r0 *ec2.GetEnabledIpamPolicyOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEnabledIpamPolicyInput, ...func(*ec2.Options)) (*ec2.GetEnabledIpamPolicyOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEnabledIpamPolicyInput, ...func(*ec2.Options)) *ec2.GetEnabledIpamPolicyOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.GetEnabledIpamPolicyOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetEnabledIpamPolicyInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_GetEnabledIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnabledIpamPolicy' +type EC2_GetEnabledIpamPolicy_Call struct { + *mock.Call +} + +// GetEnabledIpamPolicy is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.GetEnabledIpamPolicyInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) GetEnabledIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetEnabledIpamPolicy_Call { + return &EC2_GetEnabledIpamPolicy_Call{Call: _e.mock.On("GetEnabledIpamPolicy", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_GetEnabledIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.GetEnabledIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_GetEnabledIpamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.GetEnabledIpamPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_GetEnabledIpamPolicy_Call) Return(_a0 *ec2.GetEnabledIpamPolicyOutput, _a1 error) *EC2_GetEnabledIpamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_GetEnabledIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.GetEnabledIpamPolicyInput, ...func(*ec2.Options)) (*ec2.GetEnabledIpamPolicyOutput, error)) *EC2_GetEnabledIpamPolicy_Call { + _c.Call.Return(run) + return _c +} + // GetFlowLogsIntegrationTemplate provides a mock function with given fields: ctx, params, optFns func (_m *EC2) GetFlowLogsIntegrationTemplate(ctx context.Context, params *ec2.GetFlowLogsIntegrationTemplateInput, optFns ...func(*ec2.Options)) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) { _va := make([]interface{}, len(optFns)) @@ -38798,6 +40426,154 @@ func (_c *EC2_GetIpamDiscoveredResourceCidrs_Call) RunAndReturn(run func(context return _c } +// GetIpamPolicyAllocationRules provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) GetIpamPolicyAllocationRules(ctx context.Context, params *ec2.GetIpamPolicyAllocationRulesInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPolicyAllocationRulesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetIpamPolicyAllocationRules") + } + + var r0 *ec2.GetIpamPolicyAllocationRulesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) (*ec2.GetIpamPolicyAllocationRulesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) *ec2.GetIpamPolicyAllocationRulesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.GetIpamPolicyAllocationRulesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_GetIpamPolicyAllocationRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPolicyAllocationRules' +type EC2_GetIpamPolicyAllocationRules_Call struct { + *mock.Call +} + +// GetIpamPolicyAllocationRules is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.GetIpamPolicyAllocationRulesInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) GetIpamPolicyAllocationRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPolicyAllocationRules_Call { + return &EC2_GetIpamPolicyAllocationRules_Call{Call: _e.mock.On("GetIpamPolicyAllocationRules", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_GetIpamPolicyAllocationRules_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPolicyAllocationRulesInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPolicyAllocationRules_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.GetIpamPolicyAllocationRulesInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_GetIpamPolicyAllocationRules_Call) Return(_a0 *ec2.GetIpamPolicyAllocationRulesOutput, _a1 error) *EC2_GetIpamPolicyAllocationRules_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_GetIpamPolicyAllocationRules_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) (*ec2.GetIpamPolicyAllocationRulesOutput, error)) *EC2_GetIpamPolicyAllocationRules_Call { + _c.Call.Return(run) + return _c +} + +// GetIpamPolicyOrganizationTargets provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) GetIpamPolicyOrganizationTargets(ctx context.Context, params *ec2.GetIpamPolicyOrganizationTargetsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPolicyOrganizationTargetsOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetIpamPolicyOrganizationTargets") + } + + var r0 *ec2.GetIpamPolicyOrganizationTargetsOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPolicyOrganizationTargetsInput, ...func(*ec2.Options)) (*ec2.GetIpamPolicyOrganizationTargetsOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPolicyOrganizationTargetsInput, ...func(*ec2.Options)) *ec2.GetIpamPolicyOrganizationTargetsOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.GetIpamPolicyOrganizationTargetsOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPolicyOrganizationTargetsInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_GetIpamPolicyOrganizationTargets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPolicyOrganizationTargets' +type EC2_GetIpamPolicyOrganizationTargets_Call struct { + *mock.Call +} + +// GetIpamPolicyOrganizationTargets is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.GetIpamPolicyOrganizationTargetsInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) GetIpamPolicyOrganizationTargets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPolicyOrganizationTargets_Call { + return &EC2_GetIpamPolicyOrganizationTargets_Call{Call: _e.mock.On("GetIpamPolicyOrganizationTargets", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_GetIpamPolicyOrganizationTargets_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPolicyOrganizationTargetsInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPolicyOrganizationTargets_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.GetIpamPolicyOrganizationTargetsInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_GetIpamPolicyOrganizationTargets_Call) Return(_a0 *ec2.GetIpamPolicyOrganizationTargetsOutput, _a1 error) *EC2_GetIpamPolicyOrganizationTargets_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_GetIpamPolicyOrganizationTargets_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPolicyOrganizationTargetsInput, ...func(*ec2.Options)) (*ec2.GetIpamPolicyOrganizationTargetsOutput, error)) *EC2_GetIpamPolicyOrganizationTargets_Call { + _c.Call.Return(run) + return _c +} + // GetIpamPoolAllocations provides a mock function with given fields: ctx, params, optFns func (_m *EC2) GetIpamPoolAllocations(ctx context.Context, params *ec2.GetIpamPoolAllocationsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPoolAllocationsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -40426,6 +42202,80 @@ func (_c *EC2_GetTransitGatewayAttachmentPropagations_Call) RunAndReturn(run fun return _c } +// GetTransitGatewayMeteringPolicyEntries provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) GetTransitGatewayMeteringPolicyEntries(ctx context.Context, params *ec2.GetTransitGatewayMeteringPolicyEntriesInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayMeteringPolicyEntriesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetTransitGatewayMeteringPolicyEntries") + } + + var r0 *ec2.GetTransitGatewayMeteringPolicyEntriesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayMeteringPolicyEntriesInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayMeteringPolicyEntriesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayMeteringPolicyEntriesInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayMeteringPolicyEntriesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.GetTransitGatewayMeteringPolicyEntriesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayMeteringPolicyEntriesInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_GetTransitGatewayMeteringPolicyEntries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayMeteringPolicyEntries' +type EC2_GetTransitGatewayMeteringPolicyEntries_Call struct { + *mock.Call +} + +// GetTransitGatewayMeteringPolicyEntries is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.GetTransitGatewayMeteringPolicyEntriesInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) GetTransitGatewayMeteringPolicyEntries(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayMeteringPolicyEntries_Call { + return &EC2_GetTransitGatewayMeteringPolicyEntries_Call{Call: _e.mock.On("GetTransitGatewayMeteringPolicyEntries", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_GetTransitGatewayMeteringPolicyEntries_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayMeteringPolicyEntriesInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayMeteringPolicyEntries_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayMeteringPolicyEntriesInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_GetTransitGatewayMeteringPolicyEntries_Call) Return(_a0 *ec2.GetTransitGatewayMeteringPolicyEntriesOutput, _a1 error) *EC2_GetTransitGatewayMeteringPolicyEntries_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_GetTransitGatewayMeteringPolicyEntries_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayMeteringPolicyEntriesInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayMeteringPolicyEntriesOutput, error)) *EC2_GetTransitGatewayMeteringPolicyEntries_Call { + _c.Call.Return(run) + return _c +} + // GetTransitGatewayMulticastDomainAssociations provides a mock function with given fields: ctx, params, optFns func (_m *EC2) GetTransitGatewayMulticastDomainAssociations(ctx context.Context, params *ec2.GetTransitGatewayMulticastDomainAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) { _va := make([]interface{}, len(optFns)) @@ -41092,6 +42942,80 @@ func (_c *EC2_GetVerifiedAccessGroupPolicy_Call) RunAndReturn(run func(context.C return _c } +// GetVpcResourcesBlockingEncryptionEnforcement provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) GetVpcResourcesBlockingEncryptionEnforcement(ctx context.Context, params *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, optFns ...func(*ec2.Options)) (*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetVpcResourcesBlockingEncryptionEnforcement") + } + + var r0 *ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, ...func(*ec2.Options)) (*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, ...func(*ec2.Options)) *ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVpcResourcesBlockingEncryptionEnforcement' +type EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call struct { + *mock.Call +} + +// GetVpcResourcesBlockingEncryptionEnforcement is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) GetVpcResourcesBlockingEncryptionEnforcement(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call { + return &EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call{Call: _e.mock.On("GetVpcResourcesBlockingEncryptionEnforcement", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call) Run(run func(ctx context.Context, params *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, optFns ...func(*ec2.Options))) *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.GetVpcResourcesBlockingEncryptionEnforcementInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call) Return(_a0 *ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, _a1 error) *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call) RunAndReturn(run func(context.Context, *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, ...func(*ec2.Options)) (*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, error)) *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call { + _c.Call.Return(run) + return _c +} + // GetVpnConnectionDeviceSampleConfiguration provides a mock function with given fields: ctx, params, optFns func (_m *EC2) GetVpnConnectionDeviceSampleConfiguration(ctx context.Context, params *ec2.GetVpnConnectionDeviceSampleConfigurationInput, optFns ...func(*ec2.Options)) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) { _va := make([]interface{}, len(optFns)) @@ -41906,6 +43830,80 @@ func (_c *EC2_ListSnapshotsInRecycleBin_Call) RunAndReturn(run func(context.Cont return _c } +// ListVolumesInRecycleBin provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) ListVolumesInRecycleBin(ctx context.Context, params *ec2.ListVolumesInRecycleBinInput, optFns ...func(*ec2.Options)) (*ec2.ListVolumesInRecycleBinOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListVolumesInRecycleBin") + } + + var r0 *ec2.ListVolumesInRecycleBinOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.ListVolumesInRecycleBinInput, ...func(*ec2.Options)) (*ec2.ListVolumesInRecycleBinOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.ListVolumesInRecycleBinInput, ...func(*ec2.Options)) *ec2.ListVolumesInRecycleBinOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.ListVolumesInRecycleBinOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.ListVolumesInRecycleBinInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_ListVolumesInRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumesInRecycleBin' +type EC2_ListVolumesInRecycleBin_Call struct { + *mock.Call +} + +// ListVolumesInRecycleBin is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.ListVolumesInRecycleBinInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) ListVolumesInRecycleBin(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ListVolumesInRecycleBin_Call { + return &EC2_ListVolumesInRecycleBin_Call{Call: _e.mock.On("ListVolumesInRecycleBin", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_ListVolumesInRecycleBin_Call) Run(run func(ctx context.Context, params *ec2.ListVolumesInRecycleBinInput, optFns ...func(*ec2.Options))) *EC2_ListVolumesInRecycleBin_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.ListVolumesInRecycleBinInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_ListVolumesInRecycleBin_Call) Return(_a0 *ec2.ListVolumesInRecycleBinOutput, _a1 error) *EC2_ListVolumesInRecycleBin_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_ListVolumesInRecycleBin_Call) RunAndReturn(run func(context.Context, *ec2.ListVolumesInRecycleBinInput, ...func(*ec2.Options)) (*ec2.ListVolumesInRecycleBinOutput, error)) *EC2_ListVolumesInRecycleBin_Call { + _c.Call.Return(run) + return _c +} + // LockSnapshot provides a mock function with given fields: ctx, params, optFns func (_m *EC2) LockSnapshot(ctx context.Context, params *ec2.LockSnapshotInput, optFns ...func(*ec2.Options)) (*ec2.LockSnapshotOutput, error) { _va := make([]interface{}, len(optFns)) @@ -43904,6 +45902,80 @@ func (_c *EC2_ModifyIpam_Call) RunAndReturn(run func(context.Context, *ec2.Modif return _c } +// ModifyIpamPolicyAllocationRules provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) ModifyIpamPolicyAllocationRules(ctx context.Context, params *ec2.ModifyIpamPolicyAllocationRulesInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamPolicyAllocationRulesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ModifyIpamPolicyAllocationRules") + } + + var r0 *ec2.ModifyIpamPolicyAllocationRulesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPolicyAllocationRulesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) *ec2.ModifyIpamPolicyAllocationRulesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.ModifyIpamPolicyAllocationRulesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_ModifyIpamPolicyAllocationRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpamPolicyAllocationRules' +type EC2_ModifyIpamPolicyAllocationRules_Call struct { + *mock.Call +} + +// ModifyIpamPolicyAllocationRules is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.ModifyIpamPolicyAllocationRulesInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) ModifyIpamPolicyAllocationRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpamPolicyAllocationRules_Call { + return &EC2_ModifyIpamPolicyAllocationRules_Call{Call: _e.mock.On("ModifyIpamPolicyAllocationRules", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_ModifyIpamPolicyAllocationRules_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamPolicyAllocationRulesInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpamPolicyAllocationRules_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.ModifyIpamPolicyAllocationRulesInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_ModifyIpamPolicyAllocationRules_Call) Return(_a0 *ec2.ModifyIpamPolicyAllocationRulesOutput, _a1 error) *EC2_ModifyIpamPolicyAllocationRules_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_ModifyIpamPolicyAllocationRules_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPolicyAllocationRulesOutput, error)) *EC2_ModifyIpamPolicyAllocationRules_Call { + _c.Call.Return(run) + return _c +} + // ModifyIpamPool provides a mock function with given fields: ctx, params, optFns func (_m *EC2) ModifyIpamPool(ctx context.Context, params *ec2.ModifyIpamPoolInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamPoolOutput, error) { _va := make([]interface{}, len(optFns)) @@ -45606,6 +47678,80 @@ func (_c *EC2_ModifyTransitGateway_Call) RunAndReturn(run func(context.Context, return _c } +// ModifyTransitGatewayMeteringPolicy provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) ModifyTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.ModifyTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayMeteringPolicyOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ModifyTransitGatewayMeteringPolicy") + } + + var r0 *ec2.ModifyTransitGatewayMeteringPolicyOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayMeteringPolicyOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) *ec2.ModifyTransitGatewayMeteringPolicyOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.ModifyTransitGatewayMeteringPolicyOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_ModifyTransitGatewayMeteringPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyTransitGatewayMeteringPolicy' +type EC2_ModifyTransitGatewayMeteringPolicy_Call struct { + *mock.Call +} + +// ModifyTransitGatewayMeteringPolicy is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.ModifyTransitGatewayMeteringPolicyInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) ModifyTransitGatewayMeteringPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyTransitGatewayMeteringPolicy_Call { + return &EC2_ModifyTransitGatewayMeteringPolicy_Call{Call: _e.mock.On("ModifyTransitGatewayMeteringPolicy", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_ModifyTransitGatewayMeteringPolicy_Call) Run(run func(ctx context.Context, params *ec2.ModifyTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options))) *EC2_ModifyTransitGatewayMeteringPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.ModifyTransitGatewayMeteringPolicyInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_ModifyTransitGatewayMeteringPolicy_Call) Return(_a0 *ec2.ModifyTransitGatewayMeteringPolicyOutput, _a1 error) *EC2_ModifyTransitGatewayMeteringPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_ModifyTransitGatewayMeteringPolicy_Call) RunAndReturn(run func(context.Context, *ec2.ModifyTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayMeteringPolicyOutput, error)) *EC2_ModifyTransitGatewayMeteringPolicy_Call { + _c.Call.Return(run) + return _c +} + // ModifyTransitGatewayPrefixListReference provides a mock function with given fields: ctx, params, optFns func (_m *EC2) ModifyTransitGatewayPrefixListReference(ctx context.Context, params *ec2.ModifyTransitGatewayPrefixListReferenceInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) { _va := make([]interface{}, len(optFns)) @@ -46642,6 +48788,80 @@ func (_c *EC2_ModifyVpcBlockPublicAccessOptions_Call) RunAndReturn(run func(cont return _c } +// ModifyVpcEncryptionControl provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) ModifyVpcEncryptionControl(ctx context.Context, params *ec2.ModifyVpcEncryptionControlInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEncryptionControlOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ModifyVpcEncryptionControl") + } + + var r0 *ec2.ModifyVpcEncryptionControlOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEncryptionControlOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEncryptionControlInput, ...func(*ec2.Options)) *ec2.ModifyVpcEncryptionControlOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.ModifyVpcEncryptionControlOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEncryptionControlInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_ModifyVpcEncryptionControl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcEncryptionControl' +type EC2_ModifyVpcEncryptionControl_Call struct { + *mock.Call +} + +// ModifyVpcEncryptionControl is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.ModifyVpcEncryptionControlInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) ModifyVpcEncryptionControl(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcEncryptionControl_Call { + return &EC2_ModifyVpcEncryptionControl_Call{Call: _e.mock.On("ModifyVpcEncryptionControl", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_ModifyVpcEncryptionControl_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcEncryptionControlInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcEncryptionControl_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.ModifyVpcEncryptionControlInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_ModifyVpcEncryptionControl_Call) Return(_a0 *ec2.ModifyVpcEncryptionControlOutput, _a1 error) *EC2_ModifyVpcEncryptionControl_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_ModifyVpcEncryptionControl_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEncryptionControlOutput, error)) *EC2_ModifyVpcEncryptionControl_Call { + _c.Call.Return(run) + return _c +} + // ModifyVpcEndpoint provides a mock function with given fields: ctx, params, optFns func (_m *EC2) ModifyVpcEndpoint(ctx context.Context, params *ec2.ModifyVpcEndpointInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointOutput, error) { _va := make([]interface{}, len(optFns)) @@ -51201,6 +53421,80 @@ func (_c *EC2_RestoreSnapshotTier_Call) RunAndReturn(run func(context.Context, * return _c } +// RestoreVolumeFromRecycleBin provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) RestoreVolumeFromRecycleBin(ctx context.Context, params *ec2.RestoreVolumeFromRecycleBinInput, optFns ...func(*ec2.Options)) (*ec2.RestoreVolumeFromRecycleBinOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RestoreVolumeFromRecycleBin") + } + + var r0 *ec2.RestoreVolumeFromRecycleBinOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreVolumeFromRecycleBinInput, ...func(*ec2.Options)) (*ec2.RestoreVolumeFromRecycleBinOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreVolumeFromRecycleBinInput, ...func(*ec2.Options)) *ec2.RestoreVolumeFromRecycleBinOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.RestoreVolumeFromRecycleBinOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreVolumeFromRecycleBinInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_RestoreVolumeFromRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreVolumeFromRecycleBin' +type EC2_RestoreVolumeFromRecycleBin_Call struct { + *mock.Call +} + +// RestoreVolumeFromRecycleBin is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.RestoreVolumeFromRecycleBinInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) RestoreVolumeFromRecycleBin(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RestoreVolumeFromRecycleBin_Call { + return &EC2_RestoreVolumeFromRecycleBin_Call{Call: _e.mock.On("RestoreVolumeFromRecycleBin", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_RestoreVolumeFromRecycleBin_Call) Run(run func(ctx context.Context, params *ec2.RestoreVolumeFromRecycleBinInput, optFns ...func(*ec2.Options))) *EC2_RestoreVolumeFromRecycleBin_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.RestoreVolumeFromRecycleBinInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_RestoreVolumeFromRecycleBin_Call) Return(_a0 *ec2.RestoreVolumeFromRecycleBinOutput, _a1 error) *EC2_RestoreVolumeFromRecycleBin_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_RestoreVolumeFromRecycleBin_Call) RunAndReturn(run func(context.Context, *ec2.RestoreVolumeFromRecycleBinInput, ...func(*ec2.Options)) (*ec2.RestoreVolumeFromRecycleBinOutput, error)) *EC2_RestoreVolumeFromRecycleBin_Call { + _c.Call.Return(run) + return _c +} + // RevokeClientVpnIngress provides a mock function with given fields: ctx, params, optFns func (_m *EC2) RevokeClientVpnIngress(ctx context.Context, params *ec2.RevokeClientVpnIngressInput, optFns ...func(*ec2.Options)) (*ec2.RevokeClientVpnIngressOutput, error) { _va := make([]interface{}, len(optFns)) @@ -52903,6 +55197,80 @@ func (_c *EC2_UpdateCapacityManagerOrganizationsAccess_Call) RunAndReturn(run fu return _c } +// UpdateInterruptibleCapacityReservationAllocation provides a mock function with given fields: ctx, params, optFns +func (_m *EC2) UpdateInterruptibleCapacityReservationAllocation(ctx context.Context, params *ec2.UpdateInterruptibleCapacityReservationAllocationInput, optFns ...func(*ec2.Options)) (*ec2.UpdateInterruptibleCapacityReservationAllocationOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateInterruptibleCapacityReservationAllocation") + } + + var r0 *ec2.UpdateInterruptibleCapacityReservationAllocationOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) (*ec2.UpdateInterruptibleCapacityReservationAllocationOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) *ec2.UpdateInterruptibleCapacityReservationAllocationOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*ec2.UpdateInterruptibleCapacityReservationAllocationOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *ec2.UpdateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// EC2_UpdateInterruptibleCapacityReservationAllocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateInterruptibleCapacityReservationAllocation' +type EC2_UpdateInterruptibleCapacityReservationAllocation_Call struct { + *mock.Call +} + +// UpdateInterruptibleCapacityReservationAllocation is a helper method to define mock.On call +// - ctx context.Context +// - params *ec2.UpdateInterruptibleCapacityReservationAllocationInput +// - optFns ...func(*ec2.Options) +func (_e *EC2_Expecter) UpdateInterruptibleCapacityReservationAllocation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UpdateInterruptibleCapacityReservationAllocation_Call { + return &EC2_UpdateInterruptibleCapacityReservationAllocation_Call{Call: _e.mock.On("UpdateInterruptibleCapacityReservationAllocation", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *EC2_UpdateInterruptibleCapacityReservationAllocation_Call) Run(run func(ctx context.Context, params *ec2.UpdateInterruptibleCapacityReservationAllocationInput, optFns ...func(*ec2.Options))) *EC2_UpdateInterruptibleCapacityReservationAllocation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*ec2.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*ec2.Options)) + } + } + run(args[0].(context.Context), args[1].(*ec2.UpdateInterruptibleCapacityReservationAllocationInput), variadicArgs...) + }) + return _c +} + +func (_c *EC2_UpdateInterruptibleCapacityReservationAllocation_Call) Return(_a0 *ec2.UpdateInterruptibleCapacityReservationAllocationOutput, _a1 error) *EC2_UpdateInterruptibleCapacityReservationAllocation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *EC2_UpdateInterruptibleCapacityReservationAllocation_Call) RunAndReturn(run func(context.Context, *ec2.UpdateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) (*ec2.UpdateInterruptibleCapacityReservationAllocationOutput, error)) *EC2_UpdateInterruptibleCapacityReservationAllocation_Call { + _c.Call.Return(run) + return _c +} + // UpdateSecurityGroupRuleDescriptionsEgress provides a mock function with given fields: ctx, params, optFns func (_m *EC2) UpdateSecurityGroupRuleDescriptionsEgress(ctx context.Context, params *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, optFns ...func(*ec2.Options)) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) { _va := make([]interface{}, len(optFns)) diff --git a/pkg/eks/mocksv2/IAM.go b/pkg/eks/mocksv2/IAM.go index 875d120db5..6491782a40 100644 --- a/pkg/eks/mocksv2/IAM.go +++ b/pkg/eks/mocksv2/IAM.go @@ -22,6 +22,80 @@ func (_m *IAM) EXPECT() *IAM_Expecter { return &IAM_Expecter{mock: &_m.Mock} } +// AcceptDelegationRequest provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) AcceptDelegationRequest(ctx context.Context, params *iam.AcceptDelegationRequestInput, optFns ...func(*iam.Options)) (*iam.AcceptDelegationRequestOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AcceptDelegationRequest") + } + + var r0 *iam.AcceptDelegationRequestOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.AcceptDelegationRequestInput, ...func(*iam.Options)) (*iam.AcceptDelegationRequestOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.AcceptDelegationRequestInput, ...func(*iam.Options)) *iam.AcceptDelegationRequestOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.AcceptDelegationRequestOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.AcceptDelegationRequestInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_AcceptDelegationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptDelegationRequest' +type IAM_AcceptDelegationRequest_Call struct { + *mock.Call +} + +// AcceptDelegationRequest is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.AcceptDelegationRequestInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) AcceptDelegationRequest(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_AcceptDelegationRequest_Call { + return &IAM_AcceptDelegationRequest_Call{Call: _e.mock.On("AcceptDelegationRequest", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_AcceptDelegationRequest_Call) Run(run func(ctx context.Context, params *iam.AcceptDelegationRequestInput, optFns ...func(*iam.Options))) *IAM_AcceptDelegationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.AcceptDelegationRequestInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_AcceptDelegationRequest_Call) Return(_a0 *iam.AcceptDelegationRequestOutput, _a1 error) *IAM_AcceptDelegationRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_AcceptDelegationRequest_Call) RunAndReturn(run func(context.Context, *iam.AcceptDelegationRequestInput, ...func(*iam.Options)) (*iam.AcceptDelegationRequestOutput, error)) *IAM_AcceptDelegationRequest_Call { + _c.Call.Return(run) + return _c +} + // AddClientIDToOpenIDConnectProvider provides a mock function with given fields: ctx, params, optFns func (_m *IAM) AddClientIDToOpenIDConnectProvider(ctx context.Context, params *iam.AddClientIDToOpenIDConnectProviderInput, optFns ...func(*iam.Options)) (*iam.AddClientIDToOpenIDConnectProviderOutput, error) { _va := make([]interface{}, len(optFns)) @@ -244,6 +318,80 @@ func (_c *IAM_AddUserToGroup_Call) RunAndReturn(run func(context.Context, *iam.A return _c } +// AssociateDelegationRequest provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) AssociateDelegationRequest(ctx context.Context, params *iam.AssociateDelegationRequestInput, optFns ...func(*iam.Options)) (*iam.AssociateDelegationRequestOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AssociateDelegationRequest") + } + + var r0 *iam.AssociateDelegationRequestOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.AssociateDelegationRequestInput, ...func(*iam.Options)) (*iam.AssociateDelegationRequestOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.AssociateDelegationRequestInput, ...func(*iam.Options)) *iam.AssociateDelegationRequestOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.AssociateDelegationRequestOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.AssociateDelegationRequestInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_AssociateDelegationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateDelegationRequest' +type IAM_AssociateDelegationRequest_Call struct { + *mock.Call +} + +// AssociateDelegationRequest is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.AssociateDelegationRequestInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) AssociateDelegationRequest(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_AssociateDelegationRequest_Call { + return &IAM_AssociateDelegationRequest_Call{Call: _e.mock.On("AssociateDelegationRequest", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_AssociateDelegationRequest_Call) Run(run func(ctx context.Context, params *iam.AssociateDelegationRequestInput, optFns ...func(*iam.Options))) *IAM_AssociateDelegationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.AssociateDelegationRequestInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_AssociateDelegationRequest_Call) Return(_a0 *iam.AssociateDelegationRequestOutput, _a1 error) *IAM_AssociateDelegationRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_AssociateDelegationRequest_Call) RunAndReturn(run func(context.Context, *iam.AssociateDelegationRequestInput, ...func(*iam.Options)) (*iam.AssociateDelegationRequestOutput, error)) *IAM_AssociateDelegationRequest_Call { + _c.Call.Return(run) + return _c +} + // AttachGroupPolicy provides a mock function with given fields: ctx, params, optFns func (_m *IAM) AttachGroupPolicy(ctx context.Context, params *iam.AttachGroupPolicyInput, optFns ...func(*iam.Options)) (*iam.AttachGroupPolicyOutput, error) { _va := make([]interface{}, len(optFns)) @@ -3796,6 +3944,80 @@ func (_c *IAM_DisableOrganizationsRootSessions_Call) RunAndReturn(run func(conte return _c } +// DisableOutboundWebIdentityFederation provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) DisableOutboundWebIdentityFederation(ctx context.Context, params *iam.DisableOutboundWebIdentityFederationInput, optFns ...func(*iam.Options)) (*iam.DisableOutboundWebIdentityFederationOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DisableOutboundWebIdentityFederation") + } + + var r0 *iam.DisableOutboundWebIdentityFederationOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.DisableOutboundWebIdentityFederationInput, ...func(*iam.Options)) (*iam.DisableOutboundWebIdentityFederationOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.DisableOutboundWebIdentityFederationInput, ...func(*iam.Options)) *iam.DisableOutboundWebIdentityFederationOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.DisableOutboundWebIdentityFederationOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.DisableOutboundWebIdentityFederationInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_DisableOutboundWebIdentityFederation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableOutboundWebIdentityFederation' +type IAM_DisableOutboundWebIdentityFederation_Call struct { + *mock.Call +} + +// DisableOutboundWebIdentityFederation is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.DisableOutboundWebIdentityFederationInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) DisableOutboundWebIdentityFederation(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_DisableOutboundWebIdentityFederation_Call { + return &IAM_DisableOutboundWebIdentityFederation_Call{Call: _e.mock.On("DisableOutboundWebIdentityFederation", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_DisableOutboundWebIdentityFederation_Call) Run(run func(ctx context.Context, params *iam.DisableOutboundWebIdentityFederationInput, optFns ...func(*iam.Options))) *IAM_DisableOutboundWebIdentityFederation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.DisableOutboundWebIdentityFederationInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_DisableOutboundWebIdentityFederation_Call) Return(_a0 *iam.DisableOutboundWebIdentityFederationOutput, _a1 error) *IAM_DisableOutboundWebIdentityFederation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_DisableOutboundWebIdentityFederation_Call) RunAndReturn(run func(context.Context, *iam.DisableOutboundWebIdentityFederationInput, ...func(*iam.Options)) (*iam.DisableOutboundWebIdentityFederationOutput, error)) *IAM_DisableOutboundWebIdentityFederation_Call { + _c.Call.Return(run) + return _c +} + // EnableMFADevice provides a mock function with given fields: ctx, params, optFns func (_m *IAM) EnableMFADevice(ctx context.Context, params *iam.EnableMFADeviceInput, optFns ...func(*iam.Options)) (*iam.EnableMFADeviceOutput, error) { _va := make([]interface{}, len(optFns)) @@ -4018,6 +4240,80 @@ func (_c *IAM_EnableOrganizationsRootSessions_Call) RunAndReturn(run func(contex return _c } +// EnableOutboundWebIdentityFederation provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) EnableOutboundWebIdentityFederation(ctx context.Context, params *iam.EnableOutboundWebIdentityFederationInput, optFns ...func(*iam.Options)) (*iam.EnableOutboundWebIdentityFederationOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for EnableOutboundWebIdentityFederation") + } + + var r0 *iam.EnableOutboundWebIdentityFederationOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.EnableOutboundWebIdentityFederationInput, ...func(*iam.Options)) (*iam.EnableOutboundWebIdentityFederationOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.EnableOutboundWebIdentityFederationInput, ...func(*iam.Options)) *iam.EnableOutboundWebIdentityFederationOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.EnableOutboundWebIdentityFederationOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.EnableOutboundWebIdentityFederationInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_EnableOutboundWebIdentityFederation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableOutboundWebIdentityFederation' +type IAM_EnableOutboundWebIdentityFederation_Call struct { + *mock.Call +} + +// EnableOutboundWebIdentityFederation is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.EnableOutboundWebIdentityFederationInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) EnableOutboundWebIdentityFederation(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_EnableOutboundWebIdentityFederation_Call { + return &IAM_EnableOutboundWebIdentityFederation_Call{Call: _e.mock.On("EnableOutboundWebIdentityFederation", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_EnableOutboundWebIdentityFederation_Call) Run(run func(ctx context.Context, params *iam.EnableOutboundWebIdentityFederationInput, optFns ...func(*iam.Options))) *IAM_EnableOutboundWebIdentityFederation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.EnableOutboundWebIdentityFederationInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_EnableOutboundWebIdentityFederation_Call) Return(_a0 *iam.EnableOutboundWebIdentityFederationOutput, _a1 error) *IAM_EnableOutboundWebIdentityFederation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_EnableOutboundWebIdentityFederation_Call) RunAndReturn(run func(context.Context, *iam.EnableOutboundWebIdentityFederationInput, ...func(*iam.Options)) (*iam.EnableOutboundWebIdentityFederationOutput, error)) *IAM_EnableOutboundWebIdentityFederation_Call { + _c.Call.Return(run) + return _c +} + // GenerateCredentialReport provides a mock function with given fields: ctx, params, optFns func (_m *IAM) GenerateCredentialReport(ctx context.Context, params *iam.GenerateCredentialReportInput, optFns ...func(*iam.Options)) (*iam.GenerateCredentialReportOutput, error) { _va := make([]interface{}, len(optFns)) @@ -4758,6 +5054,80 @@ func (_c *IAM_GetCredentialReport_Call) RunAndReturn(run func(context.Context, * return _c } +// GetDelegationRequest provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) GetDelegationRequest(ctx context.Context, params *iam.GetDelegationRequestInput, optFns ...func(*iam.Options)) (*iam.GetDelegationRequestOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetDelegationRequest") + } + + var r0 *iam.GetDelegationRequestOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.GetDelegationRequestInput, ...func(*iam.Options)) (*iam.GetDelegationRequestOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.GetDelegationRequestInput, ...func(*iam.Options)) *iam.GetDelegationRequestOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.GetDelegationRequestOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.GetDelegationRequestInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_GetDelegationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDelegationRequest' +type IAM_GetDelegationRequest_Call struct { + *mock.Call +} + +// GetDelegationRequest is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.GetDelegationRequestInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) GetDelegationRequest(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_GetDelegationRequest_Call { + return &IAM_GetDelegationRequest_Call{Call: _e.mock.On("GetDelegationRequest", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_GetDelegationRequest_Call) Run(run func(ctx context.Context, params *iam.GetDelegationRequestInput, optFns ...func(*iam.Options))) *IAM_GetDelegationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.GetDelegationRequestInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_GetDelegationRequest_Call) Return(_a0 *iam.GetDelegationRequestOutput, _a1 error) *IAM_GetDelegationRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_GetDelegationRequest_Call) RunAndReturn(run func(context.Context, *iam.GetDelegationRequestInput, ...func(*iam.Options)) (*iam.GetDelegationRequestOutput, error)) *IAM_GetDelegationRequest_Call { + _c.Call.Return(run) + return _c +} + // GetGroup provides a mock function with given fields: ctx, params, optFns func (_m *IAM) GetGroup(ctx context.Context, params *iam.GetGroupInput, optFns ...func(*iam.Options)) (*iam.GetGroupOutput, error) { _va := make([]interface{}, len(optFns)) @@ -4906,6 +5276,80 @@ func (_c *IAM_GetGroupPolicy_Call) RunAndReturn(run func(context.Context, *iam.G return _c } +// GetHumanReadableSummary provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) GetHumanReadableSummary(ctx context.Context, params *iam.GetHumanReadableSummaryInput, optFns ...func(*iam.Options)) (*iam.GetHumanReadableSummaryOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetHumanReadableSummary") + } + + var r0 *iam.GetHumanReadableSummaryOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.GetHumanReadableSummaryInput, ...func(*iam.Options)) (*iam.GetHumanReadableSummaryOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.GetHumanReadableSummaryInput, ...func(*iam.Options)) *iam.GetHumanReadableSummaryOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.GetHumanReadableSummaryOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.GetHumanReadableSummaryInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_GetHumanReadableSummary_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHumanReadableSummary' +type IAM_GetHumanReadableSummary_Call struct { + *mock.Call +} + +// GetHumanReadableSummary is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.GetHumanReadableSummaryInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) GetHumanReadableSummary(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_GetHumanReadableSummary_Call { + return &IAM_GetHumanReadableSummary_Call{Call: _e.mock.On("GetHumanReadableSummary", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_GetHumanReadableSummary_Call) Run(run func(ctx context.Context, params *iam.GetHumanReadableSummaryInput, optFns ...func(*iam.Options))) *IAM_GetHumanReadableSummary_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.GetHumanReadableSummaryInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_GetHumanReadableSummary_Call) Return(_a0 *iam.GetHumanReadableSummaryOutput, _a1 error) *IAM_GetHumanReadableSummary_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_GetHumanReadableSummary_Call) RunAndReturn(run func(context.Context, *iam.GetHumanReadableSummaryInput, ...func(*iam.Options)) (*iam.GetHumanReadableSummaryOutput, error)) *IAM_GetHumanReadableSummary_Call { + _c.Call.Return(run) + return _c +} + // GetInstanceProfile provides a mock function with given fields: ctx, params, optFns func (_m *IAM) GetInstanceProfile(ctx context.Context, params *iam.GetInstanceProfileInput, optFns ...func(*iam.Options)) (*iam.GetInstanceProfileOutput, error) { _va := make([]interface{}, len(optFns)) @@ -5172,14 +5616,88 @@ type IAM_GetOpenIDConnectProvider_Call struct { // GetOpenIDConnectProvider is a helper method to define mock.On call // - ctx context.Context -// - params *iam.GetOpenIDConnectProviderInput +// - params *iam.GetOpenIDConnectProviderInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) GetOpenIDConnectProvider(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_GetOpenIDConnectProvider_Call { + return &IAM_GetOpenIDConnectProvider_Call{Call: _e.mock.On("GetOpenIDConnectProvider", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_GetOpenIDConnectProvider_Call) Run(run func(ctx context.Context, params *iam.GetOpenIDConnectProviderInput, optFns ...func(*iam.Options))) *IAM_GetOpenIDConnectProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.GetOpenIDConnectProviderInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_GetOpenIDConnectProvider_Call) Return(_a0 *iam.GetOpenIDConnectProviderOutput, _a1 error) *IAM_GetOpenIDConnectProvider_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_GetOpenIDConnectProvider_Call) RunAndReturn(run func(context.Context, *iam.GetOpenIDConnectProviderInput, ...func(*iam.Options)) (*iam.GetOpenIDConnectProviderOutput, error)) *IAM_GetOpenIDConnectProvider_Call { + _c.Call.Return(run) + return _c +} + +// GetOrganizationsAccessReport provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) GetOrganizationsAccessReport(ctx context.Context, params *iam.GetOrganizationsAccessReportInput, optFns ...func(*iam.Options)) (*iam.GetOrganizationsAccessReportOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetOrganizationsAccessReport") + } + + var r0 *iam.GetOrganizationsAccessReportOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.GetOrganizationsAccessReportInput, ...func(*iam.Options)) (*iam.GetOrganizationsAccessReportOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.GetOrganizationsAccessReportInput, ...func(*iam.Options)) *iam.GetOrganizationsAccessReportOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.GetOrganizationsAccessReportOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.GetOrganizationsAccessReportInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_GetOrganizationsAccessReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationsAccessReport' +type IAM_GetOrganizationsAccessReport_Call struct { + *mock.Call +} + +// GetOrganizationsAccessReport is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.GetOrganizationsAccessReportInput // - optFns ...func(*iam.Options) -func (_e *IAM_Expecter) GetOpenIDConnectProvider(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_GetOpenIDConnectProvider_Call { - return &IAM_GetOpenIDConnectProvider_Call{Call: _e.mock.On("GetOpenIDConnectProvider", +func (_e *IAM_Expecter) GetOrganizationsAccessReport(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_GetOrganizationsAccessReport_Call { + return &IAM_GetOrganizationsAccessReport_Call{Call: _e.mock.On("GetOrganizationsAccessReport", append([]interface{}{ctx, params}, optFns...)...)} } -func (_c *IAM_GetOpenIDConnectProvider_Call) Run(run func(ctx context.Context, params *iam.GetOpenIDConnectProviderInput, optFns ...func(*iam.Options))) *IAM_GetOpenIDConnectProvider_Call { +func (_c *IAM_GetOrganizationsAccessReport_Call) Run(run func(ctx context.Context, params *iam.GetOrganizationsAccessReportInput, optFns ...func(*iam.Options))) *IAM_GetOrganizationsAccessReport_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]func(*iam.Options), len(args)-2) for i, a := range args[2:] { @@ -5187,23 +5705,23 @@ func (_c *IAM_GetOpenIDConnectProvider_Call) Run(run func(ctx context.Context, p variadicArgs[i] = a.(func(*iam.Options)) } } - run(args[0].(context.Context), args[1].(*iam.GetOpenIDConnectProviderInput), variadicArgs...) + run(args[0].(context.Context), args[1].(*iam.GetOrganizationsAccessReportInput), variadicArgs...) }) return _c } -func (_c *IAM_GetOpenIDConnectProvider_Call) Return(_a0 *iam.GetOpenIDConnectProviderOutput, _a1 error) *IAM_GetOpenIDConnectProvider_Call { +func (_c *IAM_GetOrganizationsAccessReport_Call) Return(_a0 *iam.GetOrganizationsAccessReportOutput, _a1 error) *IAM_GetOrganizationsAccessReport_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *IAM_GetOpenIDConnectProvider_Call) RunAndReturn(run func(context.Context, *iam.GetOpenIDConnectProviderInput, ...func(*iam.Options)) (*iam.GetOpenIDConnectProviderOutput, error)) *IAM_GetOpenIDConnectProvider_Call { +func (_c *IAM_GetOrganizationsAccessReport_Call) RunAndReturn(run func(context.Context, *iam.GetOrganizationsAccessReportInput, ...func(*iam.Options)) (*iam.GetOrganizationsAccessReportOutput, error)) *IAM_GetOrganizationsAccessReport_Call { _c.Call.Return(run) return _c } -// GetOrganizationsAccessReport provides a mock function with given fields: ctx, params, optFns -func (_m *IAM) GetOrganizationsAccessReport(ctx context.Context, params *iam.GetOrganizationsAccessReportInput, optFns ...func(*iam.Options)) (*iam.GetOrganizationsAccessReportOutput, error) { +// GetOutboundWebIdentityFederationInfo provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) GetOutboundWebIdentityFederationInfo(ctx context.Context, params *iam.GetOutboundWebIdentityFederationInfoInput, optFns ...func(*iam.Options)) (*iam.GetOutboundWebIdentityFederationInfoOutput, error) { _va := make([]interface{}, len(optFns)) for _i := range optFns { _va[_i] = optFns[_i] @@ -5214,23 +5732,23 @@ func (_m *IAM) GetOrganizationsAccessReport(ctx context.Context, params *iam.Get ret := _m.Called(_ca...) if len(ret) == 0 { - panic("no return value specified for GetOrganizationsAccessReport") + panic("no return value specified for GetOutboundWebIdentityFederationInfo") } - var r0 *iam.GetOrganizationsAccessReportOutput + var r0 *iam.GetOutboundWebIdentityFederationInfoOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *iam.GetOrganizationsAccessReportInput, ...func(*iam.Options)) (*iam.GetOrganizationsAccessReportOutput, error)); ok { + if rf, ok := ret.Get(0).(func(context.Context, *iam.GetOutboundWebIdentityFederationInfoInput, ...func(*iam.Options)) (*iam.GetOutboundWebIdentityFederationInfoOutput, error)); ok { return rf(ctx, params, optFns...) } - if rf, ok := ret.Get(0).(func(context.Context, *iam.GetOrganizationsAccessReportInput, ...func(*iam.Options)) *iam.GetOrganizationsAccessReportOutput); ok { + if rf, ok := ret.Get(0).(func(context.Context, *iam.GetOutboundWebIdentityFederationInfoInput, ...func(*iam.Options)) *iam.GetOutboundWebIdentityFederationInfoOutput); ok { r0 = rf(ctx, params, optFns...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*iam.GetOrganizationsAccessReportOutput) + r0 = ret.Get(0).(*iam.GetOutboundWebIdentityFederationInfoOutput) } } - if rf, ok := ret.Get(1).(func(context.Context, *iam.GetOrganizationsAccessReportInput, ...func(*iam.Options)) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *iam.GetOutboundWebIdentityFederationInfoInput, ...func(*iam.Options)) error); ok { r1 = rf(ctx, params, optFns...) } else { r1 = ret.Error(1) @@ -5239,21 +5757,21 @@ func (_m *IAM) GetOrganizationsAccessReport(ctx context.Context, params *iam.Get return r0, r1 } -// IAM_GetOrganizationsAccessReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrganizationsAccessReport' -type IAM_GetOrganizationsAccessReport_Call struct { +// IAM_GetOutboundWebIdentityFederationInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOutboundWebIdentityFederationInfo' +type IAM_GetOutboundWebIdentityFederationInfo_Call struct { *mock.Call } -// GetOrganizationsAccessReport is a helper method to define mock.On call +// GetOutboundWebIdentityFederationInfo is a helper method to define mock.On call // - ctx context.Context -// - params *iam.GetOrganizationsAccessReportInput +// - params *iam.GetOutboundWebIdentityFederationInfoInput // - optFns ...func(*iam.Options) -func (_e *IAM_Expecter) GetOrganizationsAccessReport(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_GetOrganizationsAccessReport_Call { - return &IAM_GetOrganizationsAccessReport_Call{Call: _e.mock.On("GetOrganizationsAccessReport", +func (_e *IAM_Expecter) GetOutboundWebIdentityFederationInfo(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_GetOutboundWebIdentityFederationInfo_Call { + return &IAM_GetOutboundWebIdentityFederationInfo_Call{Call: _e.mock.On("GetOutboundWebIdentityFederationInfo", append([]interface{}{ctx, params}, optFns...)...)} } -func (_c *IAM_GetOrganizationsAccessReport_Call) Run(run func(ctx context.Context, params *iam.GetOrganizationsAccessReportInput, optFns ...func(*iam.Options))) *IAM_GetOrganizationsAccessReport_Call { +func (_c *IAM_GetOutboundWebIdentityFederationInfo_Call) Run(run func(ctx context.Context, params *iam.GetOutboundWebIdentityFederationInfoInput, optFns ...func(*iam.Options))) *IAM_GetOutboundWebIdentityFederationInfo_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]func(*iam.Options), len(args)-2) for i, a := range args[2:] { @@ -5261,17 +5779,17 @@ func (_c *IAM_GetOrganizationsAccessReport_Call) Run(run func(ctx context.Contex variadicArgs[i] = a.(func(*iam.Options)) } } - run(args[0].(context.Context), args[1].(*iam.GetOrganizationsAccessReportInput), variadicArgs...) + run(args[0].(context.Context), args[1].(*iam.GetOutboundWebIdentityFederationInfoInput), variadicArgs...) }) return _c } -func (_c *IAM_GetOrganizationsAccessReport_Call) Return(_a0 *iam.GetOrganizationsAccessReportOutput, _a1 error) *IAM_GetOrganizationsAccessReport_Call { +func (_c *IAM_GetOutboundWebIdentityFederationInfo_Call) Return(_a0 *iam.GetOutboundWebIdentityFederationInfoOutput, _a1 error) *IAM_GetOutboundWebIdentityFederationInfo_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *IAM_GetOrganizationsAccessReport_Call) RunAndReturn(run func(context.Context, *iam.GetOrganizationsAccessReportInput, ...func(*iam.Options)) (*iam.GetOrganizationsAccessReportOutput, error)) *IAM_GetOrganizationsAccessReport_Call { +func (_c *IAM_GetOutboundWebIdentityFederationInfo_Call) RunAndReturn(run func(context.Context, *iam.GetOutboundWebIdentityFederationInfoInput, ...func(*iam.Options)) (*iam.GetOutboundWebIdentityFederationInfoOutput, error)) *IAM_GetOutboundWebIdentityFederationInfo_Call { _c.Call.Return(run) return _c } @@ -6534,6 +7052,80 @@ func (_c *IAM_ListAttachedUserPolicies_Call) RunAndReturn(run func(context.Conte return _c } +// ListDelegationRequests provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) ListDelegationRequests(ctx context.Context, params *iam.ListDelegationRequestsInput, optFns ...func(*iam.Options)) (*iam.ListDelegationRequestsOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListDelegationRequests") + } + + var r0 *iam.ListDelegationRequestsOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.ListDelegationRequestsInput, ...func(*iam.Options)) (*iam.ListDelegationRequestsOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.ListDelegationRequestsInput, ...func(*iam.Options)) *iam.ListDelegationRequestsOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.ListDelegationRequestsOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.ListDelegationRequestsInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_ListDelegationRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDelegationRequests' +type IAM_ListDelegationRequests_Call struct { + *mock.Call +} + +// ListDelegationRequests is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.ListDelegationRequestsInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) ListDelegationRequests(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_ListDelegationRequests_Call { + return &IAM_ListDelegationRequests_Call{Call: _e.mock.On("ListDelegationRequests", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_ListDelegationRequests_Call) Run(run func(ctx context.Context, params *iam.ListDelegationRequestsInput, optFns ...func(*iam.Options))) *IAM_ListDelegationRequests_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.ListDelegationRequestsInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_ListDelegationRequests_Call) Return(_a0 *iam.ListDelegationRequestsOutput, _a1 error) *IAM_ListDelegationRequests_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_ListDelegationRequests_Call) RunAndReturn(run func(context.Context, *iam.ListDelegationRequestsInput, ...func(*iam.Options)) (*iam.ListDelegationRequestsOutput, error)) *IAM_ListDelegationRequests_Call { + _c.Call.Return(run) + return _c +} + // ListEntitiesForPolicy provides a mock function with given fields: ctx, params, optFns func (_m *IAM) ListEntitiesForPolicy(ctx context.Context, params *iam.ListEntitiesForPolicyInput, optFns ...func(*iam.Options)) (*iam.ListEntitiesForPolicyOutput, error) { _va := make([]interface{}, len(optFns)) @@ -9169,6 +9761,80 @@ func (_c *IAM_PutUserPolicy_Call) RunAndReturn(run func(context.Context, *iam.Pu return _c } +// RejectDelegationRequest provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) RejectDelegationRequest(ctx context.Context, params *iam.RejectDelegationRequestInput, optFns ...func(*iam.Options)) (*iam.RejectDelegationRequestOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RejectDelegationRequest") + } + + var r0 *iam.RejectDelegationRequestOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.RejectDelegationRequestInput, ...func(*iam.Options)) (*iam.RejectDelegationRequestOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.RejectDelegationRequestInput, ...func(*iam.Options)) *iam.RejectDelegationRequestOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.RejectDelegationRequestOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.RejectDelegationRequestInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_RejectDelegationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectDelegationRequest' +type IAM_RejectDelegationRequest_Call struct { + *mock.Call +} + +// RejectDelegationRequest is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.RejectDelegationRequestInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) RejectDelegationRequest(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_RejectDelegationRequest_Call { + return &IAM_RejectDelegationRequest_Call{Call: _e.mock.On("RejectDelegationRequest", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_RejectDelegationRequest_Call) Run(run func(ctx context.Context, params *iam.RejectDelegationRequestInput, optFns ...func(*iam.Options))) *IAM_RejectDelegationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.RejectDelegationRequestInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_RejectDelegationRequest_Call) Return(_a0 *iam.RejectDelegationRequestOutput, _a1 error) *IAM_RejectDelegationRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_RejectDelegationRequest_Call) RunAndReturn(run func(context.Context, *iam.RejectDelegationRequestInput, ...func(*iam.Options)) (*iam.RejectDelegationRequestOutput, error)) *IAM_RejectDelegationRequest_Call { + _c.Call.Return(run) + return _c +} + // RemoveClientIDFromOpenIDConnectProvider provides a mock function with given fields: ctx, params, optFns func (_m *IAM) RemoveClientIDFromOpenIDConnectProvider(ctx context.Context, params *iam.RemoveClientIDFromOpenIDConnectProviderInput, optFns ...func(*iam.Options)) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error) { _va := make([]interface{}, len(optFns)) @@ -9539,6 +10205,80 @@ func (_c *IAM_ResyncMFADevice_Call) RunAndReturn(run func(context.Context, *iam. return _c } +// SendDelegationToken provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) SendDelegationToken(ctx context.Context, params *iam.SendDelegationTokenInput, optFns ...func(*iam.Options)) (*iam.SendDelegationTokenOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SendDelegationToken") + } + + var r0 *iam.SendDelegationTokenOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.SendDelegationTokenInput, ...func(*iam.Options)) (*iam.SendDelegationTokenOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.SendDelegationTokenInput, ...func(*iam.Options)) *iam.SendDelegationTokenOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.SendDelegationTokenOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.SendDelegationTokenInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_SendDelegationToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendDelegationToken' +type IAM_SendDelegationToken_Call struct { + *mock.Call +} + +// SendDelegationToken is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.SendDelegationTokenInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) SendDelegationToken(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_SendDelegationToken_Call { + return &IAM_SendDelegationToken_Call{Call: _e.mock.On("SendDelegationToken", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_SendDelegationToken_Call) Run(run func(ctx context.Context, params *iam.SendDelegationTokenInput, optFns ...func(*iam.Options))) *IAM_SendDelegationToken_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.SendDelegationTokenInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_SendDelegationToken_Call) Return(_a0 *iam.SendDelegationTokenOutput, _a1 error) *IAM_SendDelegationToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_SendDelegationToken_Call) RunAndReturn(run func(context.Context, *iam.SendDelegationTokenInput, ...func(*iam.Options)) (*iam.SendDelegationTokenOutput, error)) *IAM_SendDelegationToken_Call { + _c.Call.Return(run) + return _c +} + // SetDefaultPolicyVersion provides a mock function with given fields: ctx, params, optFns func (_m *IAM) SetDefaultPolicyVersion(ctx context.Context, params *iam.SetDefaultPolicyVersionInput, optFns ...func(*iam.Options)) (*iam.SetDefaultPolicyVersionOutput, error) { _va := make([]interface{}, len(optFns)) @@ -11241,6 +11981,80 @@ func (_c *IAM_UpdateAssumeRolePolicy_Call) RunAndReturn(run func(context.Context return _c } +// UpdateDelegationRequest provides a mock function with given fields: ctx, params, optFns +func (_m *IAM) UpdateDelegationRequest(ctx context.Context, params *iam.UpdateDelegationRequestInput, optFns ...func(*iam.Options)) (*iam.UpdateDelegationRequestOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UpdateDelegationRequest") + } + + var r0 *iam.UpdateDelegationRequestOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateDelegationRequestInput, ...func(*iam.Options)) (*iam.UpdateDelegationRequestOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateDelegationRequestInput, ...func(*iam.Options)) *iam.UpdateDelegationRequestOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam.UpdateDelegationRequestOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateDelegationRequestInput, ...func(*iam.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IAM_UpdateDelegationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDelegationRequest' +type IAM_UpdateDelegationRequest_Call struct { + *mock.Call +} + +// UpdateDelegationRequest is a helper method to define mock.On call +// - ctx context.Context +// - params *iam.UpdateDelegationRequestInput +// - optFns ...func(*iam.Options) +func (_e *IAM_Expecter) UpdateDelegationRequest(ctx interface{}, params interface{}, optFns ...interface{}) *IAM_UpdateDelegationRequest_Call { + return &IAM_UpdateDelegationRequest_Call{Call: _e.mock.On("UpdateDelegationRequest", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *IAM_UpdateDelegationRequest_Call) Run(run func(ctx context.Context, params *iam.UpdateDelegationRequestInput, optFns ...func(*iam.Options))) *IAM_UpdateDelegationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*iam.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*iam.Options)) + } + } + run(args[0].(context.Context), args[1].(*iam.UpdateDelegationRequestInput), variadicArgs...) + }) + return _c +} + +func (_c *IAM_UpdateDelegationRequest_Call) Return(_a0 *iam.UpdateDelegationRequestOutput, _a1 error) *IAM_UpdateDelegationRequest_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *IAM_UpdateDelegationRequest_Call) RunAndReturn(run func(context.Context, *iam.UpdateDelegationRequestInput, ...func(*iam.Options)) (*iam.UpdateDelegationRequestOutput, error)) *IAM_UpdateDelegationRequest_Call { + _c.Call.Return(run) + return _c +} + // UpdateGroup provides a mock function with given fields: ctx, params, optFns func (_m *IAM) UpdateGroup(ctx context.Context, params *iam.UpdateGroupInput, optFns ...func(*iam.Options)) (*iam.UpdateGroupOutput, error) { _va := make([]interface{}, len(optFns)) diff --git a/pkg/nodebootstrap/al2023.go b/pkg/nodebootstrap/al2023.go index c7324b3983..1dbffbda1b 100644 --- a/pkg/nodebootstrap/al2023.go +++ b/pkg/nodebootstrap/al2023.go @@ -133,18 +133,24 @@ func (m *AL2023) createMinimalNodeConfig() (*nodeadm.NodeConfig, error) { serviceCIDR = clusterStatus.KubernetesNetworkConfig.ServiceIPv4CIDR } + clusterDetails := nodeadm.ClusterDetails{ + Name: m.cfg.Metadata.Name, + APIServerEndpoint: clusterStatus.Endpoint, + CertificateAuthority: clusterStatus.CertificateAuthorityData, + CIDR: serviceCIDR, + } + if m.cfg.IsControlPlaneOnOutposts() { + clusterDetails.ID = m.cfg.ID() + clusterDetails.EnableOutpost = ptr(true) + } + return &nodeadm.NodeConfig{ TypeMeta: metav1.TypeMeta{ Kind: nodeadmapi.KindNodeConfig, APIVersion: nodeadm.GroupVersion.String(), }, Spec: nodeadm.NodeConfigSpec{ - Cluster: nodeadm.ClusterDetails{ - Name: m.cfg.Metadata.Name, - APIServerEndpoint: clusterStatus.Endpoint, - CertificateAuthority: clusterStatus.CertificateAuthorityData, - CIDR: serviceCIDR, - }, + Cluster: clusterDetails, Kubelet: kubeletOptions, }, }, nil @@ -171,3 +177,5 @@ func stringToNodeConfig(overrideBootstrapCommand string) (*nodeadm.NodeConfig, e } return &config, nil } + +func ptr[T any](v T) *T { return &v } diff --git a/pkg/nodebootstrap/al2023_test.go b/pkg/nodebootstrap/al2023_test.go index d58c177a42..077f85b23b 100644 --- a/pkg/nodebootstrap/al2023_test.go +++ b/pkg/nodebootstrap/al2023_test.go @@ -30,6 +30,9 @@ type al2023Entry struct { var _ = DescribeTable("Unmanaged AL2023", func(e al2023Entry) { cfg, dns := makeDefaultClusterSettings() + if e.overrideClusterSettings != nil { + e.overrideClusterSettings(cfg) + } ng := api.NewNodeGroup() makeDefaultNPSettings(ng) @@ -56,6 +59,14 @@ var _ = DescribeTable("Unmanaged AL2023", func(e al2023Entry) { }, expectedUserData: wrapMIMEParts(nodeConfig), }), + Entry("control plane on Outposts", al2023Entry{ + overrideClusterSettings: func(cc *api.ClusterConfig) { + cc.Outpost = &api.Outpost{ + ControlPlaneOutpostARN: "arn:aws:outposts:us-west-2:1234:outpost/op-1234", + } + cc.Status.ID = "51eaebb5-7e52-4e71-baba-e98a6314b10e" + }, expectedUserData: wrapMIMEParts(nodeConfigOutpost), + }), ) var _ = DescribeTable("Managed AL2023", func(e al2023Entry) { @@ -404,6 +415,33 @@ spec: - --node-labels=alpha.eksctl.io/nodegroup-name=al2023-mng-test ` + + nodeConfigOutpost = `--// +Content-Type: application/node.eks.aws + +apiVersion: node.eks.aws/v1alpha1 +kind: NodeConfig +metadata: {} +spec: + cluster: + apiServerEndpoint: https://test.xxx.us-west-2.eks.amazonaws.com + certificateAuthority: dGVzdCBDQQ== + cidr: 10.100.0.0/16 + enableOutpost: true + id: 51eaebb5-7e52-4e71-baba-e98a6314b10e + name: al2023-test + containerd: {} + instance: + localStorage: {} + kubelet: + config: + clusterDNS: + - 10.100.0.10 + flags: + - --node-labels=alpha.eksctl.io/nodegroup-name=al2023-mng-test + +` + managedNodeConfigIPv6 = `--// Content-Type: application/node.eks.aws diff --git a/userdocs/src/usage/outposts.md b/userdocs/src/usage/outposts.md index 413c3526d0..8bc6135347 100644 --- a/userdocs/src/usage/outposts.md +++ b/userdocs/src/usage/outposts.md @@ -204,7 +204,7 @@ nodeGroups: ``` ???+ note - - Only Amazon Linux 2 is supported for nodegroups when the control plane is on Outposts. + - Only Amazon Linux 2023 is supported for nodegroups when the control plane is on Outposts. - Only EBS gp2 volume types are supported for nodegroups on Outposts.