diff --git a/controllers/awsmachine_controller.go b/controllers/awsmachine_controller.go index 317cc204db..98f3b31278 100644 --- a/controllers/awsmachine_controller.go +++ b/controllers/awsmachine_controller.go @@ -737,7 +737,7 @@ func (r *AWSMachineReconciler) createInstance(ctx context.Context, ec2svc servic return nil, errors.Wrapf(userDataErr, "failed to resolve userdata") } - instance, err := ec2svc.CreateInstance(machineScope, userData, userDataFormat) + instance, err := ec2svc.CreateInstance(ctx, machineScope, userData, userDataFormat) if err != nil { return nil, errors.Wrapf(err, "failed to create AWSMachine instance") } diff --git a/controllers/awsmachine_controller_unit_test.go b/controllers/awsmachine_controller_unit_test.go index 1c1493c4f9..c4166a50dc 100644 --- a/controllers/awsmachine_controller_unit_test.go +++ b/controllers/awsmachine_controller_unit_test.go @@ -313,7 +313,7 @@ func TestAWSMachineReconciler(t *testing.T) { expectedErr := errors.New("Invalid instance") ec2Svc.EXPECT().InstanceIfExists(gomock.Any()).Return(nil, nil) secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return("test", int32(1), nil).Times(1) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, expectedErr) + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, expectedErr) secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) _, err := reconciler.reconcileNormal(context.Background(), ms, cs, cs, cs, cs) @@ -349,7 +349,7 @@ func TestAWSMachineReconciler(t *testing.T) { instance.State = infrav1.InstanceStatePending ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, nil) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) } t.Run("instance security group errors", func(t *testing.T) { @@ -785,7 +785,7 @@ func TestAWSMachineReconciler(t *testing.T) { return elbSvc } - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, nil) elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, errors.New("error describing ELB")) secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) @@ -811,7 +811,7 @@ func TestAWSMachineReconciler(t *testing.T) { return elbSvc } - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, nil) elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, nil) elbSvc.EXPECT().RegisterInstanceWithAPIServerELB(gomock.Any()).Return(errors.New("failed to attach ELB")) @@ -842,7 +842,7 @@ func TestAWSMachineReconciler(t *testing.T) { ensureTag := func(t *testing.T, g *WithT) { t.Helper() ec2Svc.EXPECT().InstanceIfExists(gomock.Any()).Return(nil, nil) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return("test", int32(1), nil) secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil) } @@ -888,7 +888,7 @@ func TestAWSMachineReconciler(t *testing.T) { ensureSecurityGroups := func(t *testing.T, g *WithT) { t.Helper() ec2Svc.EXPECT().InstanceIfExists(gomock.Any()).Return(nil, nil) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil) secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return("test", int32(1), nil) secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil) ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil) @@ -1011,7 +1011,7 @@ func TestAWSMachineReconciler(t *testing.T) { ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, nil).AnyTimes() secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return(secretPrefix, int32(1), nil).Times(1) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1) ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1) @@ -1048,7 +1048,7 @@ func TestAWSMachineReconciler(t *testing.T) { ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, nil).AnyTimes() secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return(secretPrefix, int32(1), nil).Times(1) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1) ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1) @@ -1304,7 +1304,7 @@ func TestAWSMachineReconciler(t *testing.T) { } instance.State = infrav1.InstanceStatePending secretSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return(secretPrefix, int32(1), nil).Times(1) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() secretSvc.EXPECT().UserData(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1) ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1) @@ -1357,7 +1357,7 @@ func TestAWSMachineReconciler(t *testing.T) { fakeS3URL := "s3://foo" objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any()).Return(fakeS3URL, nil).Times(1) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1) ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1) ec2Svc.EXPECT().GetAdditionalSecurityGroupsIDs(gomock.Any()).Return(nil, nil) @@ -1392,7 +1392,7 @@ func TestAWSMachineReconciler(t *testing.T) { presigned := "https://cluster-api-aws.s3.us-west-2.amazonaws.com/bootstrap-data.yaml?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA3SGQVQG7FGA6KKA6%2F20221104%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20221104T140227Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=b228dbec8c1008c80c162e1210e4503dceead1e4d4751b4d9787314fd6da4d55" objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any()).Return(presigned, nil).Times(1) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1) ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1) ec2Svc.EXPECT().GetAdditionalSecurityGroupsIDs(gomock.Any()).Return(nil, nil) @@ -1611,7 +1611,7 @@ func TestAWSMachineReconciler(t *testing.T) { // Expect no Cluster Object Store to be created. objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any()).Return(fakeS3URL, nil).Times(0) - ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() + ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes() ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1) ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1) ec2Svc.EXPECT().GetAdditionalSecurityGroupsIDs(gomock.Any()).Return(nil, nil) diff --git a/exp/controllers/awsmachinepool_controller_test.go b/exp/controllers/awsmachinepool_controller_test.go index 6fd89e4b27..02dfae1911 100644 --- a/exp/controllers/awsmachinepool_controller_test.go +++ b/exp/controllers/awsmachinepool_controller_test.go @@ -703,7 +703,7 @@ func TestAWSMachinePoolReconciler(t *testing.T) { defer teardown(t, g) ec2Svc.EXPECT().GetLaunchTemplate(gomock.Eq("test")).Return(nil, "", nil, nil, nil) - ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any()).Return(ptr.To[string]("ami-abcdef123"), nil) + ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any(), gomock.Any()).Return(ptr.To[string]("ami-abcdef123"), nil) ec2Svc.EXPECT().CreateLaunchTemplate(gomock.Any(), gomock.Eq(ptr.To[string]("ami-abcdef123")), gomock.Eq(userDataSecretKey), gomock.Eq([]byte("shell-script")), gomock.Eq(userdata.ComputeHash([]byte("shell-script")))).Return("lt-ghijkl456", nil) asgSvc.EXPECT().GetASGByName(gomock.Any()).Return(nil, nil) asgSvc.EXPECT().CreateASG(gomock.Any()).DoAndReturn(func(scope *scope.MachinePoolScope) (*expinfrav1.AutoScalingGroup, error) { @@ -740,7 +740,7 @@ func TestAWSMachinePoolReconciler(t *testing.T) { &userDataSecretKey, nil, nil) - ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) // no change + ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any(), gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) // no change ec2Svc.EXPECT().LaunchTemplateNeedsUpdate(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil) asgSvc.EXPECT().GetASGByName(gomock.Any()).DoAndReturn(func(scope *scope.MachinePoolScope) (*expinfrav1.AutoScalingGroup, error) { @@ -789,7 +789,7 @@ func TestAWSMachinePoolReconciler(t *testing.T) { &userDataSecretKey, nil, nil) - ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any()).Return(ptr.To[string]("ami-different"), nil) + ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any(), gomock.Any()).Return(ptr.To[string]("ami-different"), nil) ec2Svc.EXPECT().LaunchTemplateNeedsUpdate(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil) asgSvc.EXPECT().CanStartASGInstanceRefresh(gomock.Any()).Return(true, nil) ec2Svc.EXPECT().PruneLaunchTemplateVersions(gomock.Any()).Return(nil, nil) @@ -845,7 +845,7 @@ func TestAWSMachinePoolReconciler(t *testing.T) { &apimachinerytypes.NamespacedName{Namespace: "default", Name: "previous-secret-name"}, nil, nil) - ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) + ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any(), gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) ec2Svc.EXPECT().LaunchTemplateNeedsUpdate(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil) asgSvc.EXPECT().CanStartASGInstanceRefresh(gomock.Any()).Return(true, nil) ec2Svc.EXPECT().PruneLaunchTemplateVersions(gomock.Any()).Return(nil, nil) @@ -887,7 +887,7 @@ func TestAWSMachinePoolReconciler(t *testing.T) { defer teardown(t, g) ec2Svc.EXPECT().GetLaunchTemplate(gomock.Eq("test")).Return(nil, "", nil, nil, nil) - ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any()).Return(ptr.To[string]("ami-abcdef123"), nil) + ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any(), gomock.Any()).Return(ptr.To[string]("ami-abcdef123"), nil) ec2Svc.EXPECT().CreateLaunchTemplate(gomock.Any(), gomock.Eq(ptr.To[string]("ami-abcdef123")), gomock.Eq(userDataSecretKey), gomock.Eq([]byte("shell-script")), gomock.Eq(userdata.ComputeHash([]byte("shell-script")))).Return("lt-ghijkl456", nil) asgSvc.EXPECT().GetASGByName(gomock.Any()).Return(nil, nil) asgSvc.EXPECT().CreateASG(gomock.Any()).DoAndReturn(func(scope *scope.MachinePoolScope) (*expinfrav1.AutoScalingGroup, error) { @@ -931,7 +931,7 @@ func TestAWSMachinePoolReconciler(t *testing.T) { &apimachinerytypes.NamespacedName{Namespace: "default", Name: "bootstrap-data"}, nil, nil) - ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) + ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any(), gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) ec2Svc.EXPECT().LaunchTemplateNeedsUpdate(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil) asgSvc.EXPECT().CanStartASGInstanceRefresh(gomock.Any()).Return(true, nil) ec2Svc.EXPECT().PruneLaunchTemplateVersions(gomock.Any()).Return(nil, nil) @@ -1017,7 +1017,7 @@ func TestAWSMachinePoolReconciler(t *testing.T) { &apimachinerytypes.NamespacedName{Namespace: "default", Name: "previous-secret-name"}, nil, nil) - ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) + ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any(), gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) ec2Svc.EXPECT().LaunchTemplateNeedsUpdate(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil) s3Mock.EXPECT().PutObject(gomock.Any(), gomock.Any()).DoAndReturn(func(ctx context.Context, input *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error) { @@ -1063,7 +1063,7 @@ func TestAWSMachinePoolReconciler(t *testing.T) { &apimachinerytypes.NamespacedName{Namespace: "default", Name: "previous-secret-name"}, nil, nil) - ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) + ec2Svc.EXPECT().DiscoverLaunchTemplateAMI(gomock.Any(), gomock.Any()).Return(ptr.To[string]("ami-existing"), nil) ec2Svc.EXPECT().LaunchTemplateNeedsUpdate(gomock.Any(), gomock.Any(), gomock.Any()).Return(false, nil) s3Mock.EXPECT().PutObject(gomock.Any(), gomock.Any()).DoAndReturn(func(ctx context.Context, input *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error) { diff --git a/go.mod b/go.mod index 493d8e7f61..20ff8b7288 100644 --- a/go.mod +++ b/go.mod @@ -15,6 +15,7 @@ require ( github.com/aws/aws-sdk-go-v2/service/eks v1.64.0 github.com/aws/aws-sdk-go-v2/service/iam v1.32.0 github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1 + github.com/aws/aws-sdk-go-v2/service/ssm v1.59.1 github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 github.com/aws/smithy-go v1.22.4 github.com/awslabs/goformation/v4 v4.19.5 diff --git a/go.sum b/go.sum index 9a00918d68..7b9746e1bd 100644 --- a/go.sum +++ b/go.sum @@ -96,6 +96,8 @@ github.com/aws/aws-sdk-go-v2/service/servicequotas v1.21.4 h1:SSDkZRAO8Ok5SoQ4BJ github.com/aws/aws-sdk-go-v2/service/servicequotas v1.21.4/go.mod h1:plXue/Zg49kU3uU6WwfCWgRR5SRINNiJf03Y/UhYOhU= github.com/aws/aws-sdk-go-v2/service/sqs v1.38.8 h1:80dpSqWMwx2dAm30Ib7J6ucz1ZHfiv5OCRwN/EnCOXQ= github.com/aws/aws-sdk-go-v2/service/sqs v1.38.8/go.mod h1:IzNt/udsXlETCdvBOL0nmyMe2t9cGmXmZgsdoZGYYhI= +github.com/aws/aws-sdk-go-v2/service/ssm v1.59.1 h1:Z4cmgV3hKuUIkhJsdn47hf/ABYHUtILfMrV+L8+kRwE= +github.com/aws/aws-sdk-go-v2/service/ssm v1.59.1/go.mod h1:PUWUl5MDiYNQkUHN9Pyd9kgtA/YhbxnSnHP+yQqzrM8= github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 h1:vN8hEbpRnL7+Hopy9dzmRle1xmDc7o8tmY0klsr175w= github.com/aws/aws-sdk-go-v2/service/sso v1.20.5/go.mod h1:qGzynb/msuZIE8I75DVRCUXw3o3ZyBmUvMwQ2t/BrGM= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 h1:Jux+gDDyi1Lruk+KHF91tK2KCuY61kzoCpvtvJJBtOE= diff --git a/pkg/cloud/converters/map_to_ssm_tags_test.go b/pkg/cloud/converters/map_to_ssm_tags_test.go new file mode 100644 index 0000000000..50174917dc --- /dev/null +++ b/pkg/cloud/converters/map_to_ssm_tags_test.go @@ -0,0 +1,91 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +package converters + +import ( + "reflect" + "testing" + + ssmtypes "github.com/aws/aws-sdk-go-v2/service/ssm/types" + + infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" +) + +func TestMapToSSMTags(t *testing.T) { + tests := []struct { + name string + input infrav1.Tags + expected []ssmtypes.Tag + }{ + { + name: "nil map", + input: nil, + expected: []ssmtypes.Tag{}, + }, + { + name: "empty map", + input: infrav1.Tags{}, + expected: []ssmtypes.Tag{}, + }, + { + name: "single key-value", + input: infrav1.Tags{"k1": "v1"}, + expected: []ssmtypes.Tag{ + {Key: strPtr("k1"), Value: strPtr("v1")}, + }, + }, + { + name: "multiple keys", + input: infrav1.Tags{"k1": "v1", "k2": "v2"}, + expected: []ssmtypes.Tag{ + {Key: strPtr("k1"), Value: strPtr("v1")}, + {Key: strPtr("k2"), Value: strPtr("v2")}, + }, + }, + { + name: "empty value string", + input: infrav1.Tags{"k1": ""}, + expected: []ssmtypes.Tag{ + {Key: strPtr("k1"), Value: strPtr("")}, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := MapToSSMTags(tt.input) + if len(got) != len(tt.expected) { + t.Errorf("got %d tags, want %d", len(got), len(tt.expected)) + return + } + gotMap := make(map[string]string) + for _, tag := range got { + gotMap[*tag.Key] = *tag.Value + } + expectedMap := make(map[string]string) + for _, tag := range tt.expected { + expectedMap[*tag.Key] = *tag.Value + } + if !reflect.DeepEqual(gotMap, expectedMap) { + t.Errorf("MapToSSMTags() = %v, want %v", gotMap, expectedMap) + } + }) + } +} + +func strPtr(s string) *string { + return &s +} diff --git a/pkg/cloud/converters/tags.go b/pkg/cloud/converters/tags.go index 54340a9858..fd85b42820 100644 --- a/pkg/cloud/converters/tags.go +++ b/pkg/cloud/converters/tags.go @@ -22,12 +22,12 @@ import ( autoscalingtypes "github.com/aws/aws-sdk-go-v2/service/autoscaling/types" iamtypes "github.com/aws/aws-sdk-go-v2/service/iam/types" + ssmtypes "github.com/aws/aws-sdk-go-v2/service/ssm/types" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" "github.com/aws/aws-sdk-go/service/elb" "github.com/aws/aws-sdk-go/service/elbv2" "github.com/aws/aws-sdk-go/service/secretsmanager" - "github.com/aws/aws-sdk-go/service/ssm" infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" ) @@ -75,6 +75,20 @@ func MapToTags(src infrav1.Tags) []*ec2.Tag { return tags } +// MapToSSMTags converts infrav1.Tags (a map of string key-value pairs) to a slice of SSM Tag objects. +func MapToSSMTags(tags infrav1.Tags) []ssmtypes.Tag { + result := make([]ssmtypes.Tag, 0, len(tags)) + for k, v := range tags { + key := k + value := v + result = append(result, ssmtypes.Tag{ + Key: &key, + Value: &value, + }) + } + return result +} + // ELBTagsToMap converts a []*elb.Tag into a infrav1.Tags. func ELBTagsToMap(src []*elb.Tag) infrav1.Tags { tags := make(infrav1.Tags, len(src)) @@ -154,25 +168,6 @@ func MapToSecretsManagerTags(src infrav1.Tags) []*secretsmanager.Tag { return tags } -// MapToSSMTags converts a infrav1.Tags to a []*ssm.Tag. -func MapToSSMTags(src infrav1.Tags) []*ssm.Tag { - tags := make([]*ssm.Tag, 0, len(src)) - - for k, v := range src { - tag := &ssm.Tag{ - Key: aws.String(k), - Value: aws.String(v), - } - - tags = append(tags, tag) - } - - // Sort so that unit tests can expect a stable order - sort.Slice(tags, func(i, j int) bool { return *tags[i].Key < *tags[j].Key }) - - return tags -} - // MapToIAMTags converts a infrav1.Tags to a []*iam.Tag. func MapToIAMTags(src infrav1.Tags) []iamtypes.Tag { tags := make([]iamtypes.Tag, 0, len(src)) diff --git a/pkg/cloud/endpointsv2/endpoints.go b/pkg/cloud/endpointsv2/endpoints.go index 13c33074e5..c061cd653f 100644 --- a/pkg/cloud/endpointsv2/endpoints.go +++ b/pkg/cloud/endpointsv2/endpoints.go @@ -25,6 +25,7 @@ import ( "github.com/aws/aws-sdk-go-v2/service/eks" "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/aws/aws-sdk-go-v2/service/ssm" smithyendpoints "github.com/aws/smithy-go/endpoints" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/logger" @@ -142,3 +143,25 @@ func (s *EKSEndpointResolver) ResolveEndpoint(ctx context.Context, params eks.En params.Region = &endpoint.SigningRegion return eks.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params) } + +// SSMEndpointResolver implements EndpointResolverV2 interface for SSM. +type SSMEndpointResolver struct { + *MultiServiceEndpointResolver +} + +// ResolveEndpoint for SSM. +func (s *SSMEndpointResolver) ResolveEndpoint(ctx context.Context, params ssm.EndpointParameters) (smithyendpoints.Endpoint, error) { + // If custom endpoint not found, return default endpoint for the service + log := logger.FromContext(ctx) + endpoint, ok := s.endpoints[ssm.ServiceID] + + if !ok { + log.Debug("Custom endpoint not found, using default endpoint") + return ssm.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params) + } + + log.Debug("Custom endpoint found, using custom endpoint", "endpoint", endpoint.URL) + params.Endpoint = &endpoint.URL + params.Region = &endpoint.SigningRegion + return ssm.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params) +} diff --git a/pkg/cloud/scope/clients.go b/pkg/cloud/scope/clients.go index b84b490cef..882e6e45ad 100644 --- a/pkg/cloud/scope/clients.go +++ b/pkg/cloud/scope/clients.go @@ -23,6 +23,7 @@ import ( "github.com/aws/aws-sdk-go-v2/service/iam" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/sqs" + "github.com/aws/aws-sdk-go-v2/service/ssm" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" @@ -36,8 +37,6 @@ import ( "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface" "github.com/aws/aws-sdk-go/service/secretsmanager" "github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface" - "github.com/aws/aws-sdk-go/service/ssm" - "github.com/aws/aws-sdk-go/service/ssm/ssmiface" "github.com/aws/aws-sdk-go/service/sts" "github.com/aws/aws-sdk-go/service/sts/stsiface" "k8s.io/apimachinery/pkg/runtime" @@ -223,13 +222,25 @@ func NewSTSClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg } // NewSSMClient creates a new Secrets API client for a given session. -func NewSSMClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) ssmiface.SSMAPI { - ssmClient := ssm.New(session.Session(), aws.NewConfig().WithLogLevel(awslogs.GetAWSLogLevel(logger.GetLogger())).WithLogger(awslogs.NewWrapLogr(logger.GetLogger()))) - ssmClient.Handlers.Build.PushFrontNamed(getUserAgentHandler()) - ssmClient.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName())) - ssmClient.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target)) +func NewSSMClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *ssm.Client { + cfg := session.SessionV2() + multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() + ssmEndpointResolver := &endpointsv2.SSMEndpointResolver{ + MultiServiceEndpointResolver: multiSvcEndpointResolver, + } + ssmOpts := []func(*ssm.Options){ + func(o *ssm.Options) { + o.Logger = logger.GetAWSLogger() + o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger()) + o.EndpointResolverV2 = ssmEndpointResolver + }, + ssm.WithAPIOptions( + awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target), + awsmetricsv2.WithCAPAUserAgentMiddleware(), + ), + } - return ssmClient + return ssm.NewFromConfig(cfg, ssmOpts...) } // NewS3Client creates a new S3 API client for a given session. diff --git a/pkg/cloud/services/ec2/ami.go b/pkg/cloud/services/ec2/ami.go index 03c3afb0cd..d46311abb5 100644 --- a/pkg/cloud/services/ec2/ami.go +++ b/pkg/cloud/services/ec2/ami.go @@ -25,10 +25,10 @@ import ( "text/template" "time" + "github.com/aws/aws-sdk-go-v2/service/ssm" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" "github.com/aws/aws-sdk-go/service/ec2/ec2iface" - "github.com/aws/aws-sdk-go/service/ssm" "github.com/blang/semver" "github.com/pkg/errors" @@ -318,7 +318,7 @@ func (s *Service) defaultBastionAMILookup() (string, error) { return *latestImage.ImageId, nil } -func (s *Service) eksAMILookup(kubernetesVersion string, architecture string, amiType *infrav1.EKSAMILookupType) (string, error) { +func (s *Service) eksAMILookup(ctx context.Context, kubernetesVersion string, architecture string, amiType *infrav1.EKSAMILookupType) (string, error) { // format ssm parameter path properly formattedVersion, err := formatVersionForEKS(kubernetesVersion) if err != nil { @@ -359,7 +359,7 @@ func (s *Service) eksAMILookup(kubernetesVersion string, architecture string, am Name: aws.String(paramName), } - out, err := s.SSMClient.GetParameter(input) + out, err := s.SSMClient.GetParameter(ctx, input) if err != nil { record.Eventf(s.scope.InfraCluster(), "FailedGetParameter", "Failed to get ami SSM parameter %q: %v", paramName, err) diff --git a/pkg/cloud/services/ec2/ami_test.go b/pkg/cloud/services/ec2/ami_test.go index b5c9ada181..c849601272 100644 --- a/pkg/cloud/services/ec2/ami_test.go +++ b/pkg/cloud/services/ec2/ami_test.go @@ -20,9 +20,10 @@ import ( "context" "testing" + "github.com/aws/aws-sdk-go-v2/service/ssm" + ssmtypes "github.com/aws/aws-sdk-go-v2/service/ssm/types" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/ec2" - "github.com/aws/aws-sdk-go/service/ssm" "github.com/golang/mock/gomock" . "github.com/onsi/gomega" "sigs.k8s.io/controller-runtime/pkg/client/fake" @@ -495,10 +496,10 @@ func TestEKSAMILookUp(t *testing.T) { arch: "x86_64", amiType: &gpuAMI, expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.GetParameter(gomock.Eq(&ssm.GetParameterInput{ + m.GetParameter(context.TODO(), gomock.Eq(&ssm.GetParameterInput{ Name: aws.String("/aws/service/eks/optimized-ami/1.23/amazon-linux-2-gpu/recommended/image_id"), })).Return(&ssm.GetParameterOutput{ - Parameter: &ssm.Parameter{ + Parameter: &ssmtypes.Parameter{ Value: aws.String("id"), }, }, nil) @@ -511,10 +512,10 @@ func TestEKSAMILookUp(t *testing.T) { k8sVersion: "v1.23.3", arch: "x86_64", expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.GetParameter(gomock.Eq(&ssm.GetParameterInput{ + m.GetParameter(context.TODO(), gomock.Eq(&ssm.GetParameterInput{ Name: aws.String("/aws/service/eks/optimized-ami/1.23/amazon-linux-2/recommended/image_id"), })).Return(&ssm.GetParameterOutput{ - Parameter: &ssm.Parameter{ + Parameter: &ssmtypes.Parameter{ Value: aws.String("id"), }, }, nil) @@ -527,7 +528,7 @@ func TestEKSAMILookUp(t *testing.T) { k8sVersion: "v1.23.3", arch: "x86_64", expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.GetParameter(gomock.Eq(&ssm.GetParameterInput{ + m.GetParameter(context.TODO(), gomock.Eq(&ssm.GetParameterInput{ Name: aws.String("/aws/service/eks/optimized-ami/1.23/amazon-linux-2/recommended/image_id"), })).Return(nil, awserrors.NewFailedDependency("dependency failure")) }, @@ -544,7 +545,7 @@ func TestEKSAMILookUp(t *testing.T) { k8sVersion: "v1.23.3", arch: "x86_64", expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.GetParameter(gomock.Eq(&ssm.GetParameterInput{ + m.GetParameter(context.TODO(), gomock.Eq(&ssm.GetParameterInput{ Name: aws.String("/aws/service/eks/optimized-ami/1.23/amazon-linux-2/recommended/image_id"), })).Return(&ssm.GetParameterOutput{}, nil) }, @@ -570,7 +571,8 @@ func TestEKSAMILookUp(t *testing.T) { s := NewService(clusterScope) s.SSMClient = ssmMock - got, err := s.eksAMILookup(tt.k8sVersion, tt.arch, tt.amiType) + ctx := context.TODO() + got, err := s.eksAMILookup(ctx, tt.k8sVersion, tt.arch, tt.amiType) if tt.wantErr { g.Expect(err).To(HaveOccurred()) return diff --git a/pkg/cloud/services/ec2/instances.go b/pkg/cloud/services/ec2/instances.go index 961f0579b8..fc4568e0de 100644 --- a/pkg/cloud/services/ec2/instances.go +++ b/pkg/cloud/services/ec2/instances.go @@ -108,7 +108,7 @@ func (s *Service) InstanceIfExists(id *string) (*infrav1.Instance, error) { // CreateInstance runs an ec2 instance. // //nolint:gocyclo // this function has multiple processes to perform -func (s *Service) CreateInstance(scope *scope.MachineScope, userData []byte, userDataFormat string) (*infrav1.Instance, error) { +func (s *Service) CreateInstance(ctx context.Context, scope *scope.MachineScope, userData []byte, userDataFormat string) (*infrav1.Instance, error) { s.scope.Debug("Creating an instance for a machine") input := &infrav1.Instance{ @@ -164,7 +164,7 @@ func (s *Service) CreateInstance(scope *scope.MachineScope, userData []byte, use } if scope.IsEKSManaged() && imageLookupFormat == "" && imageLookupOrg == "" && imageLookupBaseOS == "" { - input.ImageID, err = s.eksAMILookup(*scope.Machine.Spec.Version, imageArchitecture, scope.AWSMachine.Spec.AMI.EKSOptimizedLookupType) + input.ImageID, err = s.eksAMILookup(ctx, *scope.Machine.Spec.Version, imageArchitecture, scope.AWSMachine.Spec.AMI.EKSOptimizedLookupType) if err != nil { return nil, err } diff --git a/pkg/cloud/services/ec2/instances_test.go b/pkg/cloud/services/ec2/instances_test.go index b4068313cc..838cfb7406 100644 --- a/pkg/cloud/services/ec2/instances_test.go +++ b/pkg/cloud/services/ec2/instances_test.go @@ -5720,7 +5720,7 @@ func TestCreateInstance(t *testing.T) { s := NewService(clusterScope) s.EC2Client = ec2Mock - instance, err := s.CreateInstance(machineScope, data, "") + instance, err := s.CreateInstance(context.TODO(), machineScope, data, "") tc.check(instance, err) }) } diff --git a/pkg/cloud/services/ec2/launchtemplate.go b/pkg/cloud/services/ec2/launchtemplate.go index e977bd29ae..163247c15a 100644 --- a/pkg/cloud/services/ec2/launchtemplate.go +++ b/pkg/cloud/services/ec2/launchtemplate.go @@ -83,7 +83,7 @@ func (s *Service) ReconcileLaunchTemplate( return err } - imageID, err := ec2svc.DiscoverLaunchTemplateAMI(scope) + imageID, err := ec2svc.DiscoverLaunchTemplateAMI(ctx, scope) if err != nil { conditions.MarkFalse(scope.GetSetter(), expinfrav1.LaunchTemplateReadyCondition, expinfrav1.LaunchTemplateCreateFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error()) return err @@ -981,7 +981,7 @@ func (s *Service) LaunchTemplateNeedsUpdate(scope scope.LaunchTemplateScope, inc } // DiscoverLaunchTemplateAMI will discover the AMI launch template. -func (s *Service) DiscoverLaunchTemplateAMI(scope scope.LaunchTemplateScope) (*string, error) { +func (s *Service) DiscoverLaunchTemplateAMI(ctx context.Context, scope scope.LaunchTemplateScope) (*string, error) { lt := scope.GetLaunchTemplate() if lt.AMI.ID != nil { @@ -1029,6 +1029,7 @@ func (s *Service) DiscoverLaunchTemplateAMI(scope scope.LaunchTemplateScope) (*s if scope.IsEKSManaged() && imageLookupFormat == "" && imageLookupOrg == "" && imageLookupBaseOS == "" { lookupAMI, err = s.eksAMILookup( + ctx, *templateVersion, imageArchitecture, scope.GetLaunchTemplate().AMI.EKSOptimizedLookupType, diff --git a/pkg/cloud/services/ec2/launchtemplate_test.go b/pkg/cloud/services/ec2/launchtemplate_test.go index a1c2965133..68e3ab52b4 100644 --- a/pkg/cloud/services/ec2/launchtemplate_test.go +++ b/pkg/cloud/services/ec2/launchtemplate_test.go @@ -21,11 +21,12 @@ import ( "encoding/base64" "testing" + "github.com/aws/aws-sdk-go-v2/service/ssm" + ssmtypes "github.com/aws/aws-sdk-go-v2/service/ssm/types" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/service/ec2" - "github.com/aws/aws-sdk-go/service/ssm" "github.com/golang/mock/gomock" "github.com/google/go-cmp/cmp" . "github.com/onsi/gomega" @@ -1921,7 +1922,7 @@ func TestDiscoverLaunchTemplateAMI(t *testing.T) { s := NewService(cs) s.EC2Client = ec2Mock - id, err := s.DiscoverLaunchTemplateAMI(ms) + id, err := s.DiscoverLaunchTemplateAMI(context.TODO(), ms) tc.check(g, id, err) }) } @@ -1956,9 +1957,9 @@ func TestDiscoverLaunchTemplateAMIForEKS(t *testing.T) { }, nil) }, expectSSM: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.GetParameter(gomock.AssignableToTypeOf(&ssm.GetParameterInput{})). + m.GetParameter(context.TODO(), gomock.AssignableToTypeOf(&ssm.GetParameterInput{})). Return(&ssm.GetParameterOutput{ - Parameter: &ssm.Parameter{ + Parameter: &ssmtypes.Parameter{ Value: aws.String("latest"), }, }, nil) @@ -1998,7 +1999,7 @@ func TestDiscoverLaunchTemplateAMIForEKS(t *testing.T) { s.EC2Client = ec2Mock s.SSMClient = ssmMock - id, err := s.DiscoverLaunchTemplateAMI(ms) + id, err := s.DiscoverLaunchTemplateAMI(context.TODO(), ms) tc.check(g, id, err) }) } diff --git a/pkg/cloud/services/ec2/service.go b/pkg/cloud/services/ec2/service.go index 03e08b1203..a833b54ad3 100644 --- a/pkg/cloud/services/ec2/service.go +++ b/pkg/cloud/services/ec2/service.go @@ -19,10 +19,10 @@ package ec2 import ( "github.com/aws/aws-sdk-go/service/ec2/ec2iface" - "github.com/aws/aws-sdk-go/service/ssm/ssmiface" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/network" + "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/ssm" ) // Service holds a collection of interfaces. @@ -34,7 +34,7 @@ type Service struct { netService *network.Service // SSMClient is used to look up the official EKS AMI ID - SSMClient ssmiface.SSMAPI + SSMClient ssm.SSMAPI } // NewService returns a new service given the ec2 api client. diff --git a/pkg/cloud/services/interfaces.go b/pkg/cloud/services/interfaces.go index 02858f386e..2641f0eec2 100644 --- a/pkg/cloud/services/interfaces.go +++ b/pkg/cloud/services/interfaces.go @@ -62,7 +62,7 @@ type ASGInterface interface { type EC2Interface interface { InstanceIfExists(id *string) (*infrav1.Instance, error) TerminateInstance(id string) error - CreateInstance(scope *scope.MachineScope, userData []byte, userDataFormat string) (*infrav1.Instance, error) + CreateInstance(ctx context.Context, scope *scope.MachineScope, userData []byte, userDataFormat string) (*infrav1.Instance, error) GetRunningInstanceByTags(scope *scope.MachineScope) (*infrav1.Instance, error) GetAdditionalSecurityGroupsIDs(securityGroup []infrav1.AWSResourceReference) ([]string, error) @@ -75,7 +75,7 @@ type EC2Interface interface { TerminateInstanceAndWait(instanceID string) error DetachSecurityGroupsFromNetworkInterface(groups []string, interfaceID string) error - DiscoverLaunchTemplateAMI(scope scope.LaunchTemplateScope) (*string, error) + DiscoverLaunchTemplateAMI(ctx context.Context, scope scope.LaunchTemplateScope) (*string, error) GetLaunchTemplate(id string) (lt *expinfrav1.AWSLaunchTemplate, userDataHash string, userDataSecretKey *apimachinerytypes.NamespacedName, bootstrapDataHash *string, err error) GetLaunchTemplateID(id string) (string, error) GetLaunchTemplateLatestVersion(id string) (string, error) diff --git a/pkg/cloud/services/mock_services/ec2_interface_mock.go b/pkg/cloud/services/mock_services/ec2_interface_mock.go index 0de1443e2c..e6e6932a70 100644 --- a/pkg/cloud/services/mock_services/ec2_interface_mock.go +++ b/pkg/cloud/services/mock_services/ec2_interface_mock.go @@ -21,6 +21,7 @@ limitations under the License. package mock_services import ( + context "context" reflect "reflect" ec2 "github.com/aws/aws-sdk-go/service/ec2" @@ -55,18 +56,18 @@ func (m *MockEC2Interface) EXPECT() *MockEC2InterfaceMockRecorder { } // CreateInstance mocks base method. -func (m *MockEC2Interface) CreateInstance(arg0 *scope.MachineScope, arg1 []byte, arg2 string) (*v1beta2.Instance, error) { +func (m *MockEC2Interface) CreateInstance(arg0 context.Context, arg1 *scope.MachineScope, arg2 []byte, arg3 string) (*v1beta2.Instance, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInstance", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "CreateInstance", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(*v1beta2.Instance) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateInstance indicates an expected call of CreateInstance. -func (mr *MockEC2InterfaceMockRecorder) CreateInstance(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockEC2InterfaceMockRecorder) CreateInstance(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstance", reflect.TypeOf((*MockEC2Interface)(nil).CreateInstance), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstance", reflect.TypeOf((*MockEC2Interface)(nil).CreateInstance), arg0, arg1, arg2, arg3) } // CreateLaunchTemplate mocks base method. @@ -141,18 +142,18 @@ func (mr *MockEC2InterfaceMockRecorder) DetachSecurityGroupsFromNetworkInterface } // DiscoverLaunchTemplateAMI mocks base method. -func (m *MockEC2Interface) DiscoverLaunchTemplateAMI(arg0 scope.LaunchTemplateScope) (*string, error) { +func (m *MockEC2Interface) DiscoverLaunchTemplateAMI(arg0 context.Context, arg1 scope.LaunchTemplateScope) (*string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DiscoverLaunchTemplateAMI", arg0) + ret := m.ctrl.Call(m, "DiscoverLaunchTemplateAMI", arg0, arg1) ret0, _ := ret[0].(*string) ret1, _ := ret[1].(error) return ret0, ret1 } // DiscoverLaunchTemplateAMI indicates an expected call of DiscoverLaunchTemplateAMI. -func (mr *MockEC2InterfaceMockRecorder) DiscoverLaunchTemplateAMI(arg0 interface{}) *gomock.Call { +func (mr *MockEC2InterfaceMockRecorder) DiscoverLaunchTemplateAMI(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverLaunchTemplateAMI", reflect.TypeOf((*MockEC2Interface)(nil).DiscoverLaunchTemplateAMI), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverLaunchTemplateAMI", reflect.TypeOf((*MockEC2Interface)(nil).DiscoverLaunchTemplateAMI), arg0, arg1) } // GetAdditionalSecurityGroupsIDs mocks base method. diff --git a/pkg/cloud/services/ssm/mock_ssmiface/doc.go b/pkg/cloud/services/ssm/mock_ssmiface/doc.go index 8188fc99d5..952d2ce8de 100644 --- a/pkg/cloud/services/ssm/mock_ssmiface/doc.go +++ b/pkg/cloud/services/ssm/mock_ssmiface/doc.go @@ -14,9 +14,9 @@ See the License for the specific language governing permissions and limitations under the License. */ -// Package mock_ssmiface provides a mock interface for the SSM API client. +// Package mock_ssmiface provides a mock implementation for the IAMAPI interface. // Run go generate to regenerate this mock. // -//go:generate ../../../../../hack/tools/bin/mockgen -destination ssmapi_mock.go -package mock_ssmiface github.com/aws/aws-sdk-go/service/ssm/ssmiface SSMAPI -//go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt ssmapi_mock.go > _ssmapi_mock.go && mv _ssmapi_mock.go ssmapi_mock.go" +//go:generate ../../../../../hack/tools/bin/mockgen -destination ssmiface_mock.go -package mock_ssmiface sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/iamauth IAMAPI +//go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt mock_ssmiface.go > _ssmiface_mock.go && mv _ssmiface_mock.go ssmiface_mock.go" package mock_ssmiface //nolint:stylecheck diff --git a/pkg/cloud/services/ssm/mock_ssmiface/mock_ssmiface.go b/pkg/cloud/services/ssm/mock_ssmiface/mock_ssmiface.go new file mode 100644 index 0000000000..292f80408e --- /dev/null +++ b/pkg/cloud/services/ssm/mock_ssmiface/mock_ssmiface.go @@ -0,0 +1,96 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: pkg/cloud/services/ssm/service.go + +// Package mock_ssmiface is a generated GoMock package. +package mock_ssmiface + +import ( + context "context" + reflect "reflect" + + ssm "github.com/aws/aws-sdk-go-v2/service/ssm" + gomock "github.com/golang/mock/gomock" +) + +// MockSSMAPI is a mock of SSMAPI interface. +type MockSSMAPI struct { + ctrl *gomock.Controller + recorder *MockSSMAPIMockRecorder +} + +// MockSSMAPIMockRecorder is the mock recorder for MockSSMAPI. +type MockSSMAPIMockRecorder struct { + mock *MockSSMAPI +} + +// NewMockSSMAPI creates a new mock instance. +func NewMockSSMAPI(ctrl *gomock.Controller) *MockSSMAPI { + mock := &MockSSMAPI{ctrl: ctrl} + mock.recorder = &MockSSMAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSSMAPI) EXPECT() *MockSSMAPIMockRecorder { + return m.recorder +} + +// DeleteParameter mocks base method. +func (m *MockSSMAPI) DeleteParameter(ctx context.Context, input *ssm.DeleteParameterInput, optFns ...func(*ssm.Options)) (*ssm.DeleteParameterOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, input} + for _, a := range optFns { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteParameter", varargs...) + ret0, _ := ret[0].(*ssm.DeleteParameterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteParameter indicates an expected call of DeleteParameter. +func (mr *MockSSMAPIMockRecorder) DeleteParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, input}, optFns...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParameter", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParameter), varargs...) +} + +// GetParameter mocks base method. +func (m *MockSSMAPI) GetParameter(ctx context.Context, input *ssm.GetParameterInput, optFns ...func(*ssm.Options)) (*ssm.GetParameterOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, input} + for _, a := range optFns { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetParameter", varargs...) + ret0, _ := ret[0].(*ssm.GetParameterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetParameter indicates an expected call of GetParameter. +func (mr *MockSSMAPIMockRecorder) GetParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, input}, optFns...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameter", reflect.TypeOf((*MockSSMAPI)(nil).GetParameter), varargs...) +} + +// PutParameter mocks base method. +func (m *MockSSMAPI) PutParameter(ctx context.Context, input *ssm.PutParameterInput, optFns ...func(*ssm.Options)) (*ssm.PutParameterOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, input} + for _, a := range optFns { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutParameter", varargs...) + ret0, _ := ret[0].(*ssm.PutParameterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutParameter indicates an expected call of PutParameter. +func (mr *MockSSMAPIMockRecorder) PutParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, input}, optFns...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutParameter", reflect.TypeOf((*MockSSMAPI)(nil).PutParameter), varargs...) +} diff --git a/pkg/cloud/services/ssm/mock_ssmiface/ssmapi_mock.go b/pkg/cloud/services/ssm/mock_ssmiface/ssmapi_mock.go deleted file mode 100644 index 99db35b228..0000000000 --- a/pkg/cloud/services/ssm/mock_ssmiface/ssmapi_mock.go +++ /dev/null @@ -1,8670 +0,0 @@ -/* -Copyright The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/aws/aws-sdk-go/service/ssm/ssmiface (interfaces: SSMAPI) - -// Package mock_ssmiface is a generated GoMock package. -package mock_ssmiface - -import ( - context "context" - reflect "reflect" - - request "github.com/aws/aws-sdk-go/aws/request" - ssm "github.com/aws/aws-sdk-go/service/ssm" - gomock "github.com/golang/mock/gomock" -) - -// MockSSMAPI is a mock of SSMAPI interface. -type MockSSMAPI struct { - ctrl *gomock.Controller - recorder *MockSSMAPIMockRecorder -} - -// MockSSMAPIMockRecorder is the mock recorder for MockSSMAPI. -type MockSSMAPIMockRecorder struct { - mock *MockSSMAPI -} - -// NewMockSSMAPI creates a new mock instance. -func NewMockSSMAPI(ctrl *gomock.Controller) *MockSSMAPI { - mock := &MockSSMAPI{ctrl: ctrl} - mock.recorder = &MockSSMAPIMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSSMAPI) EXPECT() *MockSSMAPIMockRecorder { - return m.recorder -} - -// AddTagsToResource mocks base method. -func (m *MockSSMAPI) AddTagsToResource(arg0 *ssm.AddTagsToResourceInput) (*ssm.AddTagsToResourceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddTagsToResource", arg0) - ret0, _ := ret[0].(*ssm.AddTagsToResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AddTagsToResource indicates an expected call of AddTagsToResource. -func (mr *MockSSMAPIMockRecorder) AddTagsToResource(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResource", reflect.TypeOf((*MockSSMAPI)(nil).AddTagsToResource), arg0) -} - -// AddTagsToResourceRequest mocks base method. -func (m *MockSSMAPI) AddTagsToResourceRequest(arg0 *ssm.AddTagsToResourceInput) (*request.Request, *ssm.AddTagsToResourceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddTagsToResourceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.AddTagsToResourceOutput) - return ret0, ret1 -} - -// AddTagsToResourceRequest indicates an expected call of AddTagsToResourceRequest. -func (mr *MockSSMAPIMockRecorder) AddTagsToResourceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResourceRequest", reflect.TypeOf((*MockSSMAPI)(nil).AddTagsToResourceRequest), arg0) -} - -// AddTagsToResourceWithContext mocks base method. -func (m *MockSSMAPI) AddTagsToResourceWithContext(arg0 context.Context, arg1 *ssm.AddTagsToResourceInput, arg2 ...request.Option) (*ssm.AddTagsToResourceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AddTagsToResourceWithContext", varargs...) - ret0, _ := ret[0].(*ssm.AddTagsToResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AddTagsToResourceWithContext indicates an expected call of AddTagsToResourceWithContext. -func (mr *MockSSMAPIMockRecorder) AddTagsToResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResourceWithContext", reflect.TypeOf((*MockSSMAPI)(nil).AddTagsToResourceWithContext), varargs...) -} - -// AssociateOpsItemRelatedItem mocks base method. -func (m *MockSSMAPI) AssociateOpsItemRelatedItem(arg0 *ssm.AssociateOpsItemRelatedItemInput) (*ssm.AssociateOpsItemRelatedItemOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateOpsItemRelatedItem", arg0) - ret0, _ := ret[0].(*ssm.AssociateOpsItemRelatedItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateOpsItemRelatedItem indicates an expected call of AssociateOpsItemRelatedItem. -func (mr *MockSSMAPIMockRecorder) AssociateOpsItemRelatedItem(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateOpsItemRelatedItem", reflect.TypeOf((*MockSSMAPI)(nil).AssociateOpsItemRelatedItem), arg0) -} - -// AssociateOpsItemRelatedItemRequest mocks base method. -func (m *MockSSMAPI) AssociateOpsItemRelatedItemRequest(arg0 *ssm.AssociateOpsItemRelatedItemInput) (*request.Request, *ssm.AssociateOpsItemRelatedItemOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateOpsItemRelatedItemRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.AssociateOpsItemRelatedItemOutput) - return ret0, ret1 -} - -// AssociateOpsItemRelatedItemRequest indicates an expected call of AssociateOpsItemRelatedItemRequest. -func (mr *MockSSMAPIMockRecorder) AssociateOpsItemRelatedItemRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateOpsItemRelatedItemRequest", reflect.TypeOf((*MockSSMAPI)(nil).AssociateOpsItemRelatedItemRequest), arg0) -} - -// AssociateOpsItemRelatedItemWithContext mocks base method. -func (m *MockSSMAPI) AssociateOpsItemRelatedItemWithContext(arg0 context.Context, arg1 *ssm.AssociateOpsItemRelatedItemInput, arg2 ...request.Option) (*ssm.AssociateOpsItemRelatedItemOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateOpsItemRelatedItemWithContext", varargs...) - ret0, _ := ret[0].(*ssm.AssociateOpsItemRelatedItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateOpsItemRelatedItemWithContext indicates an expected call of AssociateOpsItemRelatedItemWithContext. -func (mr *MockSSMAPIMockRecorder) AssociateOpsItemRelatedItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateOpsItemRelatedItemWithContext", reflect.TypeOf((*MockSSMAPI)(nil).AssociateOpsItemRelatedItemWithContext), varargs...) -} - -// CancelCommand mocks base method. -func (m *MockSSMAPI) CancelCommand(arg0 *ssm.CancelCommandInput) (*ssm.CancelCommandOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelCommand", arg0) - ret0, _ := ret[0].(*ssm.CancelCommandOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelCommand indicates an expected call of CancelCommand. -func (mr *MockSSMAPIMockRecorder) CancelCommand(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCommand", reflect.TypeOf((*MockSSMAPI)(nil).CancelCommand), arg0) -} - -// CancelCommandRequest mocks base method. -func (m *MockSSMAPI) CancelCommandRequest(arg0 *ssm.CancelCommandInput) (*request.Request, *ssm.CancelCommandOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelCommandRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CancelCommandOutput) - return ret0, ret1 -} - -// CancelCommandRequest indicates an expected call of CancelCommandRequest. -func (mr *MockSSMAPIMockRecorder) CancelCommandRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCommandRequest", reflect.TypeOf((*MockSSMAPI)(nil).CancelCommandRequest), arg0) -} - -// CancelCommandWithContext mocks base method. -func (m *MockSSMAPI) CancelCommandWithContext(arg0 context.Context, arg1 *ssm.CancelCommandInput, arg2 ...request.Option) (*ssm.CancelCommandOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelCommandWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CancelCommandOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelCommandWithContext indicates an expected call of CancelCommandWithContext. -func (mr *MockSSMAPIMockRecorder) CancelCommandWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCommandWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CancelCommandWithContext), varargs...) -} - -// CancelMaintenanceWindowExecution mocks base method. -func (m *MockSSMAPI) CancelMaintenanceWindowExecution(arg0 *ssm.CancelMaintenanceWindowExecutionInput) (*ssm.CancelMaintenanceWindowExecutionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelMaintenanceWindowExecution", arg0) - ret0, _ := ret[0].(*ssm.CancelMaintenanceWindowExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelMaintenanceWindowExecution indicates an expected call of CancelMaintenanceWindowExecution. -func (mr *MockSSMAPIMockRecorder) CancelMaintenanceWindowExecution(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelMaintenanceWindowExecution", reflect.TypeOf((*MockSSMAPI)(nil).CancelMaintenanceWindowExecution), arg0) -} - -// CancelMaintenanceWindowExecutionRequest mocks base method. -func (m *MockSSMAPI) CancelMaintenanceWindowExecutionRequest(arg0 *ssm.CancelMaintenanceWindowExecutionInput) (*request.Request, *ssm.CancelMaintenanceWindowExecutionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelMaintenanceWindowExecutionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CancelMaintenanceWindowExecutionOutput) - return ret0, ret1 -} - -// CancelMaintenanceWindowExecutionRequest indicates an expected call of CancelMaintenanceWindowExecutionRequest. -func (mr *MockSSMAPIMockRecorder) CancelMaintenanceWindowExecutionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelMaintenanceWindowExecutionRequest", reflect.TypeOf((*MockSSMAPI)(nil).CancelMaintenanceWindowExecutionRequest), arg0) -} - -// CancelMaintenanceWindowExecutionWithContext mocks base method. -func (m *MockSSMAPI) CancelMaintenanceWindowExecutionWithContext(arg0 context.Context, arg1 *ssm.CancelMaintenanceWindowExecutionInput, arg2 ...request.Option) (*ssm.CancelMaintenanceWindowExecutionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelMaintenanceWindowExecutionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CancelMaintenanceWindowExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelMaintenanceWindowExecutionWithContext indicates an expected call of CancelMaintenanceWindowExecutionWithContext. -func (mr *MockSSMAPIMockRecorder) CancelMaintenanceWindowExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelMaintenanceWindowExecutionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CancelMaintenanceWindowExecutionWithContext), varargs...) -} - -// CreateActivation mocks base method. -func (m *MockSSMAPI) CreateActivation(arg0 *ssm.CreateActivationInput) (*ssm.CreateActivationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateActivation", arg0) - ret0, _ := ret[0].(*ssm.CreateActivationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateActivation indicates an expected call of CreateActivation. -func (mr *MockSSMAPIMockRecorder) CreateActivation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateActivation", reflect.TypeOf((*MockSSMAPI)(nil).CreateActivation), arg0) -} - -// CreateActivationRequest mocks base method. -func (m *MockSSMAPI) CreateActivationRequest(arg0 *ssm.CreateActivationInput) (*request.Request, *ssm.CreateActivationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateActivationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreateActivationOutput) - return ret0, ret1 -} - -// CreateActivationRequest indicates an expected call of CreateActivationRequest. -func (mr *MockSSMAPIMockRecorder) CreateActivationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateActivationRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreateActivationRequest), arg0) -} - -// CreateActivationWithContext mocks base method. -func (m *MockSSMAPI) CreateActivationWithContext(arg0 context.Context, arg1 *ssm.CreateActivationInput, arg2 ...request.Option) (*ssm.CreateActivationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateActivationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreateActivationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateActivationWithContext indicates an expected call of CreateActivationWithContext. -func (mr *MockSSMAPIMockRecorder) CreateActivationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateActivationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreateActivationWithContext), varargs...) -} - -// CreateAssociation mocks base method. -func (m *MockSSMAPI) CreateAssociation(arg0 *ssm.CreateAssociationInput) (*ssm.CreateAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateAssociation", arg0) - ret0, _ := ret[0].(*ssm.CreateAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateAssociation indicates an expected call of CreateAssociation. -func (mr *MockSSMAPIMockRecorder) CreateAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssociation", reflect.TypeOf((*MockSSMAPI)(nil).CreateAssociation), arg0) -} - -// CreateAssociationBatch mocks base method. -func (m *MockSSMAPI) CreateAssociationBatch(arg0 *ssm.CreateAssociationBatchInput) (*ssm.CreateAssociationBatchOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateAssociationBatch", arg0) - ret0, _ := ret[0].(*ssm.CreateAssociationBatchOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateAssociationBatch indicates an expected call of CreateAssociationBatch. -func (mr *MockSSMAPIMockRecorder) CreateAssociationBatch(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssociationBatch", reflect.TypeOf((*MockSSMAPI)(nil).CreateAssociationBatch), arg0) -} - -// CreateAssociationBatchRequest mocks base method. -func (m *MockSSMAPI) CreateAssociationBatchRequest(arg0 *ssm.CreateAssociationBatchInput) (*request.Request, *ssm.CreateAssociationBatchOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateAssociationBatchRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreateAssociationBatchOutput) - return ret0, ret1 -} - -// CreateAssociationBatchRequest indicates an expected call of CreateAssociationBatchRequest. -func (mr *MockSSMAPIMockRecorder) CreateAssociationBatchRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssociationBatchRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreateAssociationBatchRequest), arg0) -} - -// CreateAssociationBatchWithContext mocks base method. -func (m *MockSSMAPI) CreateAssociationBatchWithContext(arg0 context.Context, arg1 *ssm.CreateAssociationBatchInput, arg2 ...request.Option) (*ssm.CreateAssociationBatchOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateAssociationBatchWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreateAssociationBatchOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateAssociationBatchWithContext indicates an expected call of CreateAssociationBatchWithContext. -func (mr *MockSSMAPIMockRecorder) CreateAssociationBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssociationBatchWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreateAssociationBatchWithContext), varargs...) -} - -// CreateAssociationRequest mocks base method. -func (m *MockSSMAPI) CreateAssociationRequest(arg0 *ssm.CreateAssociationInput) (*request.Request, *ssm.CreateAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreateAssociationOutput) - return ret0, ret1 -} - -// CreateAssociationRequest indicates an expected call of CreateAssociationRequest. -func (mr *MockSSMAPIMockRecorder) CreateAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssociationRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreateAssociationRequest), arg0) -} - -// CreateAssociationWithContext mocks base method. -func (m *MockSSMAPI) CreateAssociationWithContext(arg0 context.Context, arg1 *ssm.CreateAssociationInput, arg2 ...request.Option) (*ssm.CreateAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreateAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateAssociationWithContext indicates an expected call of CreateAssociationWithContext. -func (mr *MockSSMAPIMockRecorder) CreateAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssociationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreateAssociationWithContext), varargs...) -} - -// CreateDocument mocks base method. -func (m *MockSSMAPI) CreateDocument(arg0 *ssm.CreateDocumentInput) (*ssm.CreateDocumentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDocument", arg0) - ret0, _ := ret[0].(*ssm.CreateDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDocument indicates an expected call of CreateDocument. -func (mr *MockSSMAPIMockRecorder) CreateDocument(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDocument", reflect.TypeOf((*MockSSMAPI)(nil).CreateDocument), arg0) -} - -// CreateDocumentRequest mocks base method. -func (m *MockSSMAPI) CreateDocumentRequest(arg0 *ssm.CreateDocumentInput) (*request.Request, *ssm.CreateDocumentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDocumentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreateDocumentOutput) - return ret0, ret1 -} - -// CreateDocumentRequest indicates an expected call of CreateDocumentRequest. -func (mr *MockSSMAPIMockRecorder) CreateDocumentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDocumentRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreateDocumentRequest), arg0) -} - -// CreateDocumentWithContext mocks base method. -func (m *MockSSMAPI) CreateDocumentWithContext(arg0 context.Context, arg1 *ssm.CreateDocumentInput, arg2 ...request.Option) (*ssm.CreateDocumentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateDocumentWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreateDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDocumentWithContext indicates an expected call of CreateDocumentWithContext. -func (mr *MockSSMAPIMockRecorder) CreateDocumentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDocumentWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreateDocumentWithContext), varargs...) -} - -// CreateMaintenanceWindow mocks base method. -func (m *MockSSMAPI) CreateMaintenanceWindow(arg0 *ssm.CreateMaintenanceWindowInput) (*ssm.CreateMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateMaintenanceWindow", arg0) - ret0, _ := ret[0].(*ssm.CreateMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateMaintenanceWindow indicates an expected call of CreateMaintenanceWindow. -func (mr *MockSSMAPIMockRecorder) CreateMaintenanceWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMaintenanceWindow", reflect.TypeOf((*MockSSMAPI)(nil).CreateMaintenanceWindow), arg0) -} - -// CreateMaintenanceWindowRequest mocks base method. -func (m *MockSSMAPI) CreateMaintenanceWindowRequest(arg0 *ssm.CreateMaintenanceWindowInput) (*request.Request, *ssm.CreateMaintenanceWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateMaintenanceWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreateMaintenanceWindowOutput) - return ret0, ret1 -} - -// CreateMaintenanceWindowRequest indicates an expected call of CreateMaintenanceWindowRequest. -func (mr *MockSSMAPIMockRecorder) CreateMaintenanceWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMaintenanceWindowRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreateMaintenanceWindowRequest), arg0) -} - -// CreateMaintenanceWindowWithContext mocks base method. -func (m *MockSSMAPI) CreateMaintenanceWindowWithContext(arg0 context.Context, arg1 *ssm.CreateMaintenanceWindowInput, arg2 ...request.Option) (*ssm.CreateMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateMaintenanceWindowWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreateMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateMaintenanceWindowWithContext indicates an expected call of CreateMaintenanceWindowWithContext. -func (mr *MockSSMAPIMockRecorder) CreateMaintenanceWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreateMaintenanceWindowWithContext), varargs...) -} - -// CreateOpsItem mocks base method. -func (m *MockSSMAPI) CreateOpsItem(arg0 *ssm.CreateOpsItemInput) (*ssm.CreateOpsItemOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateOpsItem", arg0) - ret0, _ := ret[0].(*ssm.CreateOpsItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateOpsItem indicates an expected call of CreateOpsItem. -func (mr *MockSSMAPIMockRecorder) CreateOpsItem(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpsItem", reflect.TypeOf((*MockSSMAPI)(nil).CreateOpsItem), arg0) -} - -// CreateOpsItemRequest mocks base method. -func (m *MockSSMAPI) CreateOpsItemRequest(arg0 *ssm.CreateOpsItemInput) (*request.Request, *ssm.CreateOpsItemOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateOpsItemRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreateOpsItemOutput) - return ret0, ret1 -} - -// CreateOpsItemRequest indicates an expected call of CreateOpsItemRequest. -func (mr *MockSSMAPIMockRecorder) CreateOpsItemRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpsItemRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreateOpsItemRequest), arg0) -} - -// CreateOpsItemWithContext mocks base method. -func (m *MockSSMAPI) CreateOpsItemWithContext(arg0 context.Context, arg1 *ssm.CreateOpsItemInput, arg2 ...request.Option) (*ssm.CreateOpsItemOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateOpsItemWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreateOpsItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateOpsItemWithContext indicates an expected call of CreateOpsItemWithContext. -func (mr *MockSSMAPIMockRecorder) CreateOpsItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpsItemWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreateOpsItemWithContext), varargs...) -} - -// CreateOpsMetadata mocks base method. -func (m *MockSSMAPI) CreateOpsMetadata(arg0 *ssm.CreateOpsMetadataInput) (*ssm.CreateOpsMetadataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateOpsMetadata", arg0) - ret0, _ := ret[0].(*ssm.CreateOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateOpsMetadata indicates an expected call of CreateOpsMetadata. -func (mr *MockSSMAPIMockRecorder) CreateOpsMetadata(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpsMetadata", reflect.TypeOf((*MockSSMAPI)(nil).CreateOpsMetadata), arg0) -} - -// CreateOpsMetadataRequest mocks base method. -func (m *MockSSMAPI) CreateOpsMetadataRequest(arg0 *ssm.CreateOpsMetadataInput) (*request.Request, *ssm.CreateOpsMetadataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateOpsMetadataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreateOpsMetadataOutput) - return ret0, ret1 -} - -// CreateOpsMetadataRequest indicates an expected call of CreateOpsMetadataRequest. -func (mr *MockSSMAPIMockRecorder) CreateOpsMetadataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpsMetadataRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreateOpsMetadataRequest), arg0) -} - -// CreateOpsMetadataWithContext mocks base method. -func (m *MockSSMAPI) CreateOpsMetadataWithContext(arg0 context.Context, arg1 *ssm.CreateOpsMetadataInput, arg2 ...request.Option) (*ssm.CreateOpsMetadataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateOpsMetadataWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreateOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateOpsMetadataWithContext indicates an expected call of CreateOpsMetadataWithContext. -func (mr *MockSSMAPIMockRecorder) CreateOpsMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpsMetadataWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreateOpsMetadataWithContext), varargs...) -} - -// CreatePatchBaseline mocks base method. -func (m *MockSSMAPI) CreatePatchBaseline(arg0 *ssm.CreatePatchBaselineInput) (*ssm.CreatePatchBaselineOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreatePatchBaseline", arg0) - ret0, _ := ret[0].(*ssm.CreatePatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreatePatchBaseline indicates an expected call of CreatePatchBaseline. -func (mr *MockSSMAPIMockRecorder) CreatePatchBaseline(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePatchBaseline", reflect.TypeOf((*MockSSMAPI)(nil).CreatePatchBaseline), arg0) -} - -// CreatePatchBaselineRequest mocks base method. -func (m *MockSSMAPI) CreatePatchBaselineRequest(arg0 *ssm.CreatePatchBaselineInput) (*request.Request, *ssm.CreatePatchBaselineOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreatePatchBaselineRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreatePatchBaselineOutput) - return ret0, ret1 -} - -// CreatePatchBaselineRequest indicates an expected call of CreatePatchBaselineRequest. -func (mr *MockSSMAPIMockRecorder) CreatePatchBaselineRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePatchBaselineRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreatePatchBaselineRequest), arg0) -} - -// CreatePatchBaselineWithContext mocks base method. -func (m *MockSSMAPI) CreatePatchBaselineWithContext(arg0 context.Context, arg1 *ssm.CreatePatchBaselineInput, arg2 ...request.Option) (*ssm.CreatePatchBaselineOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreatePatchBaselineWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreatePatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreatePatchBaselineWithContext indicates an expected call of CreatePatchBaselineWithContext. -func (mr *MockSSMAPIMockRecorder) CreatePatchBaselineWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePatchBaselineWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreatePatchBaselineWithContext), varargs...) -} - -// CreateResourceDataSync mocks base method. -func (m *MockSSMAPI) CreateResourceDataSync(arg0 *ssm.CreateResourceDataSyncInput) (*ssm.CreateResourceDataSyncOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateResourceDataSync", arg0) - ret0, _ := ret[0].(*ssm.CreateResourceDataSyncOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateResourceDataSync indicates an expected call of CreateResourceDataSync. -func (mr *MockSSMAPIMockRecorder) CreateResourceDataSync(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceDataSync", reflect.TypeOf((*MockSSMAPI)(nil).CreateResourceDataSync), arg0) -} - -// CreateResourceDataSyncRequest mocks base method. -func (m *MockSSMAPI) CreateResourceDataSyncRequest(arg0 *ssm.CreateResourceDataSyncInput) (*request.Request, *ssm.CreateResourceDataSyncOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateResourceDataSyncRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.CreateResourceDataSyncOutput) - return ret0, ret1 -} - -// CreateResourceDataSyncRequest indicates an expected call of CreateResourceDataSyncRequest. -func (mr *MockSSMAPIMockRecorder) CreateResourceDataSyncRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceDataSyncRequest", reflect.TypeOf((*MockSSMAPI)(nil).CreateResourceDataSyncRequest), arg0) -} - -// CreateResourceDataSyncWithContext mocks base method. -func (m *MockSSMAPI) CreateResourceDataSyncWithContext(arg0 context.Context, arg1 *ssm.CreateResourceDataSyncInput, arg2 ...request.Option) (*ssm.CreateResourceDataSyncOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateResourceDataSyncWithContext", varargs...) - ret0, _ := ret[0].(*ssm.CreateResourceDataSyncOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateResourceDataSyncWithContext indicates an expected call of CreateResourceDataSyncWithContext. -func (mr *MockSSMAPIMockRecorder) CreateResourceDataSyncWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceDataSyncWithContext", reflect.TypeOf((*MockSSMAPI)(nil).CreateResourceDataSyncWithContext), varargs...) -} - -// DeleteActivation mocks base method. -func (m *MockSSMAPI) DeleteActivation(arg0 *ssm.DeleteActivationInput) (*ssm.DeleteActivationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteActivation", arg0) - ret0, _ := ret[0].(*ssm.DeleteActivationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteActivation indicates an expected call of DeleteActivation. -func (mr *MockSSMAPIMockRecorder) DeleteActivation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteActivation", reflect.TypeOf((*MockSSMAPI)(nil).DeleteActivation), arg0) -} - -// DeleteActivationRequest mocks base method. -func (m *MockSSMAPI) DeleteActivationRequest(arg0 *ssm.DeleteActivationInput) (*request.Request, *ssm.DeleteActivationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteActivationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteActivationOutput) - return ret0, ret1 -} - -// DeleteActivationRequest indicates an expected call of DeleteActivationRequest. -func (mr *MockSSMAPIMockRecorder) DeleteActivationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteActivationRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteActivationRequest), arg0) -} - -// DeleteActivationWithContext mocks base method. -func (m *MockSSMAPI) DeleteActivationWithContext(arg0 context.Context, arg1 *ssm.DeleteActivationInput, arg2 ...request.Option) (*ssm.DeleteActivationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteActivationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteActivationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteActivationWithContext indicates an expected call of DeleteActivationWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteActivationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteActivationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteActivationWithContext), varargs...) -} - -// DeleteAssociation mocks base method. -func (m *MockSSMAPI) DeleteAssociation(arg0 *ssm.DeleteAssociationInput) (*ssm.DeleteAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteAssociation", arg0) - ret0, _ := ret[0].(*ssm.DeleteAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteAssociation indicates an expected call of DeleteAssociation. -func (mr *MockSSMAPIMockRecorder) DeleteAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssociation", reflect.TypeOf((*MockSSMAPI)(nil).DeleteAssociation), arg0) -} - -// DeleteAssociationRequest mocks base method. -func (m *MockSSMAPI) DeleteAssociationRequest(arg0 *ssm.DeleteAssociationInput) (*request.Request, *ssm.DeleteAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteAssociationOutput) - return ret0, ret1 -} - -// DeleteAssociationRequest indicates an expected call of DeleteAssociationRequest. -func (mr *MockSSMAPIMockRecorder) DeleteAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssociationRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteAssociationRequest), arg0) -} - -// DeleteAssociationWithContext mocks base method. -func (m *MockSSMAPI) DeleteAssociationWithContext(arg0 context.Context, arg1 *ssm.DeleteAssociationInput, arg2 ...request.Option) (*ssm.DeleteAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteAssociationWithContext indicates an expected call of DeleteAssociationWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssociationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteAssociationWithContext), varargs...) -} - -// DeleteDocument mocks base method. -func (m *MockSSMAPI) DeleteDocument(arg0 *ssm.DeleteDocumentInput) (*ssm.DeleteDocumentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteDocument", arg0) - ret0, _ := ret[0].(*ssm.DeleteDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteDocument indicates an expected call of DeleteDocument. -func (mr *MockSSMAPIMockRecorder) DeleteDocument(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDocument", reflect.TypeOf((*MockSSMAPI)(nil).DeleteDocument), arg0) -} - -// DeleteDocumentRequest mocks base method. -func (m *MockSSMAPI) DeleteDocumentRequest(arg0 *ssm.DeleteDocumentInput) (*request.Request, *ssm.DeleteDocumentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteDocumentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteDocumentOutput) - return ret0, ret1 -} - -// DeleteDocumentRequest indicates an expected call of DeleteDocumentRequest. -func (mr *MockSSMAPIMockRecorder) DeleteDocumentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDocumentRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteDocumentRequest), arg0) -} - -// DeleteDocumentWithContext mocks base method. -func (m *MockSSMAPI) DeleteDocumentWithContext(arg0 context.Context, arg1 *ssm.DeleteDocumentInput, arg2 ...request.Option) (*ssm.DeleteDocumentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteDocumentWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteDocumentWithContext indicates an expected call of DeleteDocumentWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteDocumentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDocumentWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteDocumentWithContext), varargs...) -} - -// DeleteInventory mocks base method. -func (m *MockSSMAPI) DeleteInventory(arg0 *ssm.DeleteInventoryInput) (*ssm.DeleteInventoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteInventory", arg0) - ret0, _ := ret[0].(*ssm.DeleteInventoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteInventory indicates an expected call of DeleteInventory. -func (mr *MockSSMAPIMockRecorder) DeleteInventory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInventory", reflect.TypeOf((*MockSSMAPI)(nil).DeleteInventory), arg0) -} - -// DeleteInventoryRequest mocks base method. -func (m *MockSSMAPI) DeleteInventoryRequest(arg0 *ssm.DeleteInventoryInput) (*request.Request, *ssm.DeleteInventoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteInventoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteInventoryOutput) - return ret0, ret1 -} - -// DeleteInventoryRequest indicates an expected call of DeleteInventoryRequest. -func (mr *MockSSMAPIMockRecorder) DeleteInventoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInventoryRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteInventoryRequest), arg0) -} - -// DeleteInventoryWithContext mocks base method. -func (m *MockSSMAPI) DeleteInventoryWithContext(arg0 context.Context, arg1 *ssm.DeleteInventoryInput, arg2 ...request.Option) (*ssm.DeleteInventoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteInventoryWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteInventoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteInventoryWithContext indicates an expected call of DeleteInventoryWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteInventoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInventoryWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteInventoryWithContext), varargs...) -} - -// DeleteMaintenanceWindow mocks base method. -func (m *MockSSMAPI) DeleteMaintenanceWindow(arg0 *ssm.DeleteMaintenanceWindowInput) (*ssm.DeleteMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteMaintenanceWindow", arg0) - ret0, _ := ret[0].(*ssm.DeleteMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteMaintenanceWindow indicates an expected call of DeleteMaintenanceWindow. -func (mr *MockSSMAPIMockRecorder) DeleteMaintenanceWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMaintenanceWindow", reflect.TypeOf((*MockSSMAPI)(nil).DeleteMaintenanceWindow), arg0) -} - -// DeleteMaintenanceWindowRequest mocks base method. -func (m *MockSSMAPI) DeleteMaintenanceWindowRequest(arg0 *ssm.DeleteMaintenanceWindowInput) (*request.Request, *ssm.DeleteMaintenanceWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteMaintenanceWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteMaintenanceWindowOutput) - return ret0, ret1 -} - -// DeleteMaintenanceWindowRequest indicates an expected call of DeleteMaintenanceWindowRequest. -func (mr *MockSSMAPIMockRecorder) DeleteMaintenanceWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMaintenanceWindowRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteMaintenanceWindowRequest), arg0) -} - -// DeleteMaintenanceWindowWithContext mocks base method. -func (m *MockSSMAPI) DeleteMaintenanceWindowWithContext(arg0 context.Context, arg1 *ssm.DeleteMaintenanceWindowInput, arg2 ...request.Option) (*ssm.DeleteMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteMaintenanceWindowWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteMaintenanceWindowWithContext indicates an expected call of DeleteMaintenanceWindowWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteMaintenanceWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteMaintenanceWindowWithContext), varargs...) -} - -// DeleteOpsItem mocks base method. -func (m *MockSSMAPI) DeleteOpsItem(arg0 *ssm.DeleteOpsItemInput) (*ssm.DeleteOpsItemOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteOpsItem", arg0) - ret0, _ := ret[0].(*ssm.DeleteOpsItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteOpsItem indicates an expected call of DeleteOpsItem. -func (mr *MockSSMAPIMockRecorder) DeleteOpsItem(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsItem", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItem), arg0) -} - -// DeleteOpsItemRequest mocks base method. -func (m *MockSSMAPI) DeleteOpsItemRequest(arg0 *ssm.DeleteOpsItemInput) (*request.Request, *ssm.DeleteOpsItemOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteOpsItemRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteOpsItemOutput) - return ret0, ret1 -} - -// DeleteOpsItemRequest indicates an expected call of DeleteOpsItemRequest. -func (mr *MockSSMAPIMockRecorder) DeleteOpsItemRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsItemRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItemRequest), arg0) -} - -// DeleteOpsItemWithContext mocks base method. -func (m *MockSSMAPI) DeleteOpsItemWithContext(arg0 context.Context, arg1 *ssm.DeleteOpsItemInput, arg2 ...request.Option) (*ssm.DeleteOpsItemOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteOpsItemWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteOpsItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteOpsItemWithContext indicates an expected call of DeleteOpsItemWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteOpsItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsItemWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItemWithContext), varargs...) -} - -// DeleteOpsMetadata mocks base method. -func (m *MockSSMAPI) DeleteOpsMetadata(arg0 *ssm.DeleteOpsMetadataInput) (*ssm.DeleteOpsMetadataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteOpsMetadata", arg0) - ret0, _ := ret[0].(*ssm.DeleteOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteOpsMetadata indicates an expected call of DeleteOpsMetadata. -func (mr *MockSSMAPIMockRecorder) DeleteOpsMetadata(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsMetadata", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsMetadata), arg0) -} - -// DeleteOpsMetadataRequest mocks base method. -func (m *MockSSMAPI) DeleteOpsMetadataRequest(arg0 *ssm.DeleteOpsMetadataInput) (*request.Request, *ssm.DeleteOpsMetadataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteOpsMetadataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteOpsMetadataOutput) - return ret0, ret1 -} - -// DeleteOpsMetadataRequest indicates an expected call of DeleteOpsMetadataRequest. -func (mr *MockSSMAPIMockRecorder) DeleteOpsMetadataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsMetadataRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsMetadataRequest), arg0) -} - -// DeleteOpsMetadataWithContext mocks base method. -func (m *MockSSMAPI) DeleteOpsMetadataWithContext(arg0 context.Context, arg1 *ssm.DeleteOpsMetadataInput, arg2 ...request.Option) (*ssm.DeleteOpsMetadataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteOpsMetadataWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteOpsMetadataWithContext indicates an expected call of DeleteOpsMetadataWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteOpsMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsMetadataWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsMetadataWithContext), varargs...) -} - -// DeleteParameter mocks base method. -func (m *MockSSMAPI) DeleteParameter(arg0 *ssm.DeleteParameterInput) (*ssm.DeleteParameterOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteParameter", arg0) - ret0, _ := ret[0].(*ssm.DeleteParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteParameter indicates an expected call of DeleteParameter. -func (mr *MockSSMAPIMockRecorder) DeleteParameter(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParameter", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParameter), arg0) -} - -// DeleteParameterRequest mocks base method. -func (m *MockSSMAPI) DeleteParameterRequest(arg0 *ssm.DeleteParameterInput) (*request.Request, *ssm.DeleteParameterOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteParameterRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteParameterOutput) - return ret0, ret1 -} - -// DeleteParameterRequest indicates an expected call of DeleteParameterRequest. -func (mr *MockSSMAPIMockRecorder) DeleteParameterRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParameterRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParameterRequest), arg0) -} - -// DeleteParameterWithContext mocks base method. -func (m *MockSSMAPI) DeleteParameterWithContext(arg0 context.Context, arg1 *ssm.DeleteParameterInput, arg2 ...request.Option) (*ssm.DeleteParameterOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteParameterWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteParameterWithContext indicates an expected call of DeleteParameterWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteParameterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParameterWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParameterWithContext), varargs...) -} - -// DeleteParameters mocks base method. -func (m *MockSSMAPI) DeleteParameters(arg0 *ssm.DeleteParametersInput) (*ssm.DeleteParametersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteParameters", arg0) - ret0, _ := ret[0].(*ssm.DeleteParametersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteParameters indicates an expected call of DeleteParameters. -func (mr *MockSSMAPIMockRecorder) DeleteParameters(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParameters", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParameters), arg0) -} - -// DeleteParametersRequest mocks base method. -func (m *MockSSMAPI) DeleteParametersRequest(arg0 *ssm.DeleteParametersInput) (*request.Request, *ssm.DeleteParametersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteParametersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteParametersOutput) - return ret0, ret1 -} - -// DeleteParametersRequest indicates an expected call of DeleteParametersRequest. -func (mr *MockSSMAPIMockRecorder) DeleteParametersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParametersRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParametersRequest), arg0) -} - -// DeleteParametersWithContext mocks base method. -func (m *MockSSMAPI) DeleteParametersWithContext(arg0 context.Context, arg1 *ssm.DeleteParametersInput, arg2 ...request.Option) (*ssm.DeleteParametersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteParametersWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteParametersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteParametersWithContext indicates an expected call of DeleteParametersWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParametersWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParametersWithContext), varargs...) -} - -// DeletePatchBaseline mocks base method. -func (m *MockSSMAPI) DeletePatchBaseline(arg0 *ssm.DeletePatchBaselineInput) (*ssm.DeletePatchBaselineOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeletePatchBaseline", arg0) - ret0, _ := ret[0].(*ssm.DeletePatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeletePatchBaseline indicates an expected call of DeletePatchBaseline. -func (mr *MockSSMAPIMockRecorder) DeletePatchBaseline(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePatchBaseline", reflect.TypeOf((*MockSSMAPI)(nil).DeletePatchBaseline), arg0) -} - -// DeletePatchBaselineRequest mocks base method. -func (m *MockSSMAPI) DeletePatchBaselineRequest(arg0 *ssm.DeletePatchBaselineInput) (*request.Request, *ssm.DeletePatchBaselineOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeletePatchBaselineRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeletePatchBaselineOutput) - return ret0, ret1 -} - -// DeletePatchBaselineRequest indicates an expected call of DeletePatchBaselineRequest. -func (mr *MockSSMAPIMockRecorder) DeletePatchBaselineRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePatchBaselineRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeletePatchBaselineRequest), arg0) -} - -// DeletePatchBaselineWithContext mocks base method. -func (m *MockSSMAPI) DeletePatchBaselineWithContext(arg0 context.Context, arg1 *ssm.DeletePatchBaselineInput, arg2 ...request.Option) (*ssm.DeletePatchBaselineOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeletePatchBaselineWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeletePatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeletePatchBaselineWithContext indicates an expected call of DeletePatchBaselineWithContext. -func (mr *MockSSMAPIMockRecorder) DeletePatchBaselineWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePatchBaselineWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeletePatchBaselineWithContext), varargs...) -} - -// DeleteResourceDataSync mocks base method. -func (m *MockSSMAPI) DeleteResourceDataSync(arg0 *ssm.DeleteResourceDataSyncInput) (*ssm.DeleteResourceDataSyncOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteResourceDataSync", arg0) - ret0, _ := ret[0].(*ssm.DeleteResourceDataSyncOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteResourceDataSync indicates an expected call of DeleteResourceDataSync. -func (mr *MockSSMAPIMockRecorder) DeleteResourceDataSync(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceDataSync", reflect.TypeOf((*MockSSMAPI)(nil).DeleteResourceDataSync), arg0) -} - -// DeleteResourceDataSyncRequest mocks base method. -func (m *MockSSMAPI) DeleteResourceDataSyncRequest(arg0 *ssm.DeleteResourceDataSyncInput) (*request.Request, *ssm.DeleteResourceDataSyncOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteResourceDataSyncRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteResourceDataSyncOutput) - return ret0, ret1 -} - -// DeleteResourceDataSyncRequest indicates an expected call of DeleteResourceDataSyncRequest. -func (mr *MockSSMAPIMockRecorder) DeleteResourceDataSyncRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceDataSyncRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteResourceDataSyncRequest), arg0) -} - -// DeleteResourceDataSyncWithContext mocks base method. -func (m *MockSSMAPI) DeleteResourceDataSyncWithContext(arg0 context.Context, arg1 *ssm.DeleteResourceDataSyncInput, arg2 ...request.Option) (*ssm.DeleteResourceDataSyncOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteResourceDataSyncWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteResourceDataSyncOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteResourceDataSyncWithContext indicates an expected call of DeleteResourceDataSyncWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteResourceDataSyncWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceDataSyncWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteResourceDataSyncWithContext), varargs...) -} - -// DeleteResourcePolicy mocks base method. -func (m *MockSSMAPI) DeleteResourcePolicy(arg0 *ssm.DeleteResourcePolicyInput) (*ssm.DeleteResourcePolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteResourcePolicy", arg0) - ret0, _ := ret[0].(*ssm.DeleteResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteResourcePolicy indicates an expected call of DeleteResourcePolicy. -func (mr *MockSSMAPIMockRecorder) DeleteResourcePolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicy", reflect.TypeOf((*MockSSMAPI)(nil).DeleteResourcePolicy), arg0) -} - -// DeleteResourcePolicyRequest mocks base method. -func (m *MockSSMAPI) DeleteResourcePolicyRequest(arg0 *ssm.DeleteResourcePolicyInput) (*request.Request, *ssm.DeleteResourcePolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteResourcePolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeleteResourcePolicyOutput) - return ret0, ret1 -} - -// DeleteResourcePolicyRequest indicates an expected call of DeleteResourcePolicyRequest. -func (mr *MockSSMAPIMockRecorder) DeleteResourcePolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicyRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteResourcePolicyRequest), arg0) -} - -// DeleteResourcePolicyWithContext mocks base method. -func (m *MockSSMAPI) DeleteResourcePolicyWithContext(arg0 context.Context, arg1 *ssm.DeleteResourcePolicyInput, arg2 ...request.Option) (*ssm.DeleteResourcePolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteResourcePolicyWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeleteResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteResourcePolicyWithContext indicates an expected call of DeleteResourcePolicyWithContext. -func (mr *MockSSMAPIMockRecorder) DeleteResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicyWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteResourcePolicyWithContext), varargs...) -} - -// DeregisterManagedInstance mocks base method. -func (m *MockSSMAPI) DeregisterManagedInstance(arg0 *ssm.DeregisterManagedInstanceInput) (*ssm.DeregisterManagedInstanceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterManagedInstance", arg0) - ret0, _ := ret[0].(*ssm.DeregisterManagedInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterManagedInstance indicates an expected call of DeregisterManagedInstance. -func (mr *MockSSMAPIMockRecorder) DeregisterManagedInstance(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterManagedInstance", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterManagedInstance), arg0) -} - -// DeregisterManagedInstanceRequest mocks base method. -func (m *MockSSMAPI) DeregisterManagedInstanceRequest(arg0 *ssm.DeregisterManagedInstanceInput) (*request.Request, *ssm.DeregisterManagedInstanceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterManagedInstanceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeregisterManagedInstanceOutput) - return ret0, ret1 -} - -// DeregisterManagedInstanceRequest indicates an expected call of DeregisterManagedInstanceRequest. -func (mr *MockSSMAPIMockRecorder) DeregisterManagedInstanceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterManagedInstanceRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterManagedInstanceRequest), arg0) -} - -// DeregisterManagedInstanceWithContext mocks base method. -func (m *MockSSMAPI) DeregisterManagedInstanceWithContext(arg0 context.Context, arg1 *ssm.DeregisterManagedInstanceInput, arg2 ...request.Option) (*ssm.DeregisterManagedInstanceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterManagedInstanceWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeregisterManagedInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterManagedInstanceWithContext indicates an expected call of DeregisterManagedInstanceWithContext. -func (mr *MockSSMAPIMockRecorder) DeregisterManagedInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterManagedInstanceWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterManagedInstanceWithContext), varargs...) -} - -// DeregisterPatchBaselineForPatchGroup mocks base method. -func (m *MockSSMAPI) DeregisterPatchBaselineForPatchGroup(arg0 *ssm.DeregisterPatchBaselineForPatchGroupInput) (*ssm.DeregisterPatchBaselineForPatchGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterPatchBaselineForPatchGroup", arg0) - ret0, _ := ret[0].(*ssm.DeregisterPatchBaselineForPatchGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterPatchBaselineForPatchGroup indicates an expected call of DeregisterPatchBaselineForPatchGroup. -func (mr *MockSSMAPIMockRecorder) DeregisterPatchBaselineForPatchGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterPatchBaselineForPatchGroup", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterPatchBaselineForPatchGroup), arg0) -} - -// DeregisterPatchBaselineForPatchGroupRequest mocks base method. -func (m *MockSSMAPI) DeregisterPatchBaselineForPatchGroupRequest(arg0 *ssm.DeregisterPatchBaselineForPatchGroupInput) (*request.Request, *ssm.DeregisterPatchBaselineForPatchGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterPatchBaselineForPatchGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeregisterPatchBaselineForPatchGroupOutput) - return ret0, ret1 -} - -// DeregisterPatchBaselineForPatchGroupRequest indicates an expected call of DeregisterPatchBaselineForPatchGroupRequest. -func (mr *MockSSMAPIMockRecorder) DeregisterPatchBaselineForPatchGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterPatchBaselineForPatchGroupRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterPatchBaselineForPatchGroupRequest), arg0) -} - -// DeregisterPatchBaselineForPatchGroupWithContext mocks base method. -func (m *MockSSMAPI) DeregisterPatchBaselineForPatchGroupWithContext(arg0 context.Context, arg1 *ssm.DeregisterPatchBaselineForPatchGroupInput, arg2 ...request.Option) (*ssm.DeregisterPatchBaselineForPatchGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterPatchBaselineForPatchGroupWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeregisterPatchBaselineForPatchGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterPatchBaselineForPatchGroupWithContext indicates an expected call of DeregisterPatchBaselineForPatchGroupWithContext. -func (mr *MockSSMAPIMockRecorder) DeregisterPatchBaselineForPatchGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterPatchBaselineForPatchGroupWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterPatchBaselineForPatchGroupWithContext), varargs...) -} - -// DeregisterTargetFromMaintenanceWindow mocks base method. -func (m *MockSSMAPI) DeregisterTargetFromMaintenanceWindow(arg0 *ssm.DeregisterTargetFromMaintenanceWindowInput) (*ssm.DeregisterTargetFromMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTargetFromMaintenanceWindow", arg0) - ret0, _ := ret[0].(*ssm.DeregisterTargetFromMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterTargetFromMaintenanceWindow indicates an expected call of DeregisterTargetFromMaintenanceWindow. -func (mr *MockSSMAPIMockRecorder) DeregisterTargetFromMaintenanceWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetFromMaintenanceWindow", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterTargetFromMaintenanceWindow), arg0) -} - -// DeregisterTargetFromMaintenanceWindowRequest mocks base method. -func (m *MockSSMAPI) DeregisterTargetFromMaintenanceWindowRequest(arg0 *ssm.DeregisterTargetFromMaintenanceWindowInput) (*request.Request, *ssm.DeregisterTargetFromMaintenanceWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTargetFromMaintenanceWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeregisterTargetFromMaintenanceWindowOutput) - return ret0, ret1 -} - -// DeregisterTargetFromMaintenanceWindowRequest indicates an expected call of DeregisterTargetFromMaintenanceWindowRequest. -func (mr *MockSSMAPIMockRecorder) DeregisterTargetFromMaintenanceWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetFromMaintenanceWindowRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterTargetFromMaintenanceWindowRequest), arg0) -} - -// DeregisterTargetFromMaintenanceWindowWithContext mocks base method. -func (m *MockSSMAPI) DeregisterTargetFromMaintenanceWindowWithContext(arg0 context.Context, arg1 *ssm.DeregisterTargetFromMaintenanceWindowInput, arg2 ...request.Option) (*ssm.DeregisterTargetFromMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterTargetFromMaintenanceWindowWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeregisterTargetFromMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterTargetFromMaintenanceWindowWithContext indicates an expected call of DeregisterTargetFromMaintenanceWindowWithContext. -func (mr *MockSSMAPIMockRecorder) DeregisterTargetFromMaintenanceWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetFromMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterTargetFromMaintenanceWindowWithContext), varargs...) -} - -// DeregisterTaskFromMaintenanceWindow mocks base method. -func (m *MockSSMAPI) DeregisterTaskFromMaintenanceWindow(arg0 *ssm.DeregisterTaskFromMaintenanceWindowInput) (*ssm.DeregisterTaskFromMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTaskFromMaintenanceWindow", arg0) - ret0, _ := ret[0].(*ssm.DeregisterTaskFromMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterTaskFromMaintenanceWindow indicates an expected call of DeregisterTaskFromMaintenanceWindow. -func (mr *MockSSMAPIMockRecorder) DeregisterTaskFromMaintenanceWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTaskFromMaintenanceWindow", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterTaskFromMaintenanceWindow), arg0) -} - -// DeregisterTaskFromMaintenanceWindowRequest mocks base method. -func (m *MockSSMAPI) DeregisterTaskFromMaintenanceWindowRequest(arg0 *ssm.DeregisterTaskFromMaintenanceWindowInput) (*request.Request, *ssm.DeregisterTaskFromMaintenanceWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTaskFromMaintenanceWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DeregisterTaskFromMaintenanceWindowOutput) - return ret0, ret1 -} - -// DeregisterTaskFromMaintenanceWindowRequest indicates an expected call of DeregisterTaskFromMaintenanceWindowRequest. -func (mr *MockSSMAPIMockRecorder) DeregisterTaskFromMaintenanceWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTaskFromMaintenanceWindowRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterTaskFromMaintenanceWindowRequest), arg0) -} - -// DeregisterTaskFromMaintenanceWindowWithContext mocks base method. -func (m *MockSSMAPI) DeregisterTaskFromMaintenanceWindowWithContext(arg0 context.Context, arg1 *ssm.DeregisterTaskFromMaintenanceWindowInput, arg2 ...request.Option) (*ssm.DeregisterTaskFromMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterTaskFromMaintenanceWindowWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DeregisterTaskFromMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterTaskFromMaintenanceWindowWithContext indicates an expected call of DeregisterTaskFromMaintenanceWindowWithContext. -func (mr *MockSSMAPIMockRecorder) DeregisterTaskFromMaintenanceWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTaskFromMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeregisterTaskFromMaintenanceWindowWithContext), varargs...) -} - -// DescribeActivations mocks base method. -func (m *MockSSMAPI) DescribeActivations(arg0 *ssm.DescribeActivationsInput) (*ssm.DescribeActivationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeActivations", arg0) - ret0, _ := ret[0].(*ssm.DescribeActivationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeActivations indicates an expected call of DescribeActivations. -func (mr *MockSSMAPIMockRecorder) DescribeActivations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeActivations", reflect.TypeOf((*MockSSMAPI)(nil).DescribeActivations), arg0) -} - -// DescribeActivationsPages mocks base method. -func (m *MockSSMAPI) DescribeActivationsPages(arg0 *ssm.DescribeActivationsInput, arg1 func(*ssm.DescribeActivationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeActivationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeActivationsPages indicates an expected call of DescribeActivationsPages. -func (mr *MockSSMAPIMockRecorder) DescribeActivationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeActivationsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeActivationsPages), arg0, arg1) -} - -// DescribeActivationsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeActivationsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeActivationsInput, arg2 func(*ssm.DescribeActivationsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeActivationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeActivationsPagesWithContext indicates an expected call of DescribeActivationsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeActivationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeActivationsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeActivationsPagesWithContext), varargs...) -} - -// DescribeActivationsRequest mocks base method. -func (m *MockSSMAPI) DescribeActivationsRequest(arg0 *ssm.DescribeActivationsInput) (*request.Request, *ssm.DescribeActivationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeActivationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeActivationsOutput) - return ret0, ret1 -} - -// DescribeActivationsRequest indicates an expected call of DescribeActivationsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeActivationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeActivationsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeActivationsRequest), arg0) -} - -// DescribeActivationsWithContext mocks base method. -func (m *MockSSMAPI) DescribeActivationsWithContext(arg0 context.Context, arg1 *ssm.DescribeActivationsInput, arg2 ...request.Option) (*ssm.DescribeActivationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeActivationsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeActivationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeActivationsWithContext indicates an expected call of DescribeActivationsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeActivationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeActivationsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeActivationsWithContext), varargs...) -} - -// DescribeAssociation mocks base method. -func (m *MockSSMAPI) DescribeAssociation(arg0 *ssm.DescribeAssociationInput) (*ssm.DescribeAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAssociation", arg0) - ret0, _ := ret[0].(*ssm.DescribeAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAssociation indicates an expected call of DescribeAssociation. -func (mr *MockSSMAPIMockRecorder) DescribeAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociation", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociation), arg0) -} - -// DescribeAssociationExecutionTargets mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionTargets(arg0 *ssm.DescribeAssociationExecutionTargetsInput) (*ssm.DescribeAssociationExecutionTargetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAssociationExecutionTargets", arg0) - ret0, _ := ret[0].(*ssm.DescribeAssociationExecutionTargetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAssociationExecutionTargets indicates an expected call of DescribeAssociationExecutionTargets. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionTargets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionTargets", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionTargets), arg0) -} - -// DescribeAssociationExecutionTargetsPages mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionTargetsPages(arg0 *ssm.DescribeAssociationExecutionTargetsInput, arg1 func(*ssm.DescribeAssociationExecutionTargetsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAssociationExecutionTargetsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAssociationExecutionTargetsPages indicates an expected call of DescribeAssociationExecutionTargetsPages. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionTargetsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionTargetsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionTargetsPages), arg0, arg1) -} - -// DescribeAssociationExecutionTargetsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionTargetsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeAssociationExecutionTargetsInput, arg2 func(*ssm.DescribeAssociationExecutionTargetsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAssociationExecutionTargetsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAssociationExecutionTargetsPagesWithContext indicates an expected call of DescribeAssociationExecutionTargetsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionTargetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionTargetsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionTargetsPagesWithContext), varargs...) -} - -// DescribeAssociationExecutionTargetsRequest mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionTargetsRequest(arg0 *ssm.DescribeAssociationExecutionTargetsInput) (*request.Request, *ssm.DescribeAssociationExecutionTargetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAssociationExecutionTargetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeAssociationExecutionTargetsOutput) - return ret0, ret1 -} - -// DescribeAssociationExecutionTargetsRequest indicates an expected call of DescribeAssociationExecutionTargetsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionTargetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionTargetsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionTargetsRequest), arg0) -} - -// DescribeAssociationExecutionTargetsWithContext mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionTargetsWithContext(arg0 context.Context, arg1 *ssm.DescribeAssociationExecutionTargetsInput, arg2 ...request.Option) (*ssm.DescribeAssociationExecutionTargetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAssociationExecutionTargetsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeAssociationExecutionTargetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAssociationExecutionTargetsWithContext indicates an expected call of DescribeAssociationExecutionTargetsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionTargetsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionTargetsWithContext), varargs...) -} - -// DescribeAssociationExecutions mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutions(arg0 *ssm.DescribeAssociationExecutionsInput) (*ssm.DescribeAssociationExecutionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAssociationExecutions", arg0) - ret0, _ := ret[0].(*ssm.DescribeAssociationExecutionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAssociationExecutions indicates an expected call of DescribeAssociationExecutions. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutions", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutions), arg0) -} - -// DescribeAssociationExecutionsPages mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionsPages(arg0 *ssm.DescribeAssociationExecutionsInput, arg1 func(*ssm.DescribeAssociationExecutionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAssociationExecutionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAssociationExecutionsPages indicates an expected call of DescribeAssociationExecutionsPages. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionsPages), arg0, arg1) -} - -// DescribeAssociationExecutionsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeAssociationExecutionsInput, arg2 func(*ssm.DescribeAssociationExecutionsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAssociationExecutionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAssociationExecutionsPagesWithContext indicates an expected call of DescribeAssociationExecutionsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionsPagesWithContext), varargs...) -} - -// DescribeAssociationExecutionsRequest mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionsRequest(arg0 *ssm.DescribeAssociationExecutionsInput) (*request.Request, *ssm.DescribeAssociationExecutionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAssociationExecutionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeAssociationExecutionsOutput) - return ret0, ret1 -} - -// DescribeAssociationExecutionsRequest indicates an expected call of DescribeAssociationExecutionsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionsRequest), arg0) -} - -// DescribeAssociationExecutionsWithContext mocks base method. -func (m *MockSSMAPI) DescribeAssociationExecutionsWithContext(arg0 context.Context, arg1 *ssm.DescribeAssociationExecutionsInput, arg2 ...request.Option) (*ssm.DescribeAssociationExecutionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAssociationExecutionsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeAssociationExecutionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAssociationExecutionsWithContext indicates an expected call of DescribeAssociationExecutionsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationExecutionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationExecutionsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationExecutionsWithContext), varargs...) -} - -// DescribeAssociationRequest mocks base method. -func (m *MockSSMAPI) DescribeAssociationRequest(arg0 *ssm.DescribeAssociationInput) (*request.Request, *ssm.DescribeAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeAssociationOutput) - return ret0, ret1 -} - -// DescribeAssociationRequest indicates an expected call of DescribeAssociationRequest. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationRequest), arg0) -} - -// DescribeAssociationWithContext mocks base method. -func (m *MockSSMAPI) DescribeAssociationWithContext(arg0 context.Context, arg1 *ssm.DescribeAssociationInput, arg2 ...request.Option) (*ssm.DescribeAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAssociationWithContext indicates an expected call of DescribeAssociationWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssociationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAssociationWithContext), varargs...) -} - -// DescribeAutomationExecutions mocks base method. -func (m *MockSSMAPI) DescribeAutomationExecutions(arg0 *ssm.DescribeAutomationExecutionsInput) (*ssm.DescribeAutomationExecutionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAutomationExecutions", arg0) - ret0, _ := ret[0].(*ssm.DescribeAutomationExecutionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAutomationExecutions indicates an expected call of DescribeAutomationExecutions. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationExecutions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationExecutions", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationExecutions), arg0) -} - -// DescribeAutomationExecutionsPages mocks base method. -func (m *MockSSMAPI) DescribeAutomationExecutionsPages(arg0 *ssm.DescribeAutomationExecutionsInput, arg1 func(*ssm.DescribeAutomationExecutionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAutomationExecutionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAutomationExecutionsPages indicates an expected call of DescribeAutomationExecutionsPages. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationExecutionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationExecutionsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationExecutionsPages), arg0, arg1) -} - -// DescribeAutomationExecutionsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeAutomationExecutionsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeAutomationExecutionsInput, arg2 func(*ssm.DescribeAutomationExecutionsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAutomationExecutionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAutomationExecutionsPagesWithContext indicates an expected call of DescribeAutomationExecutionsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationExecutionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationExecutionsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationExecutionsPagesWithContext), varargs...) -} - -// DescribeAutomationExecutionsRequest mocks base method. -func (m *MockSSMAPI) DescribeAutomationExecutionsRequest(arg0 *ssm.DescribeAutomationExecutionsInput) (*request.Request, *ssm.DescribeAutomationExecutionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAutomationExecutionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeAutomationExecutionsOutput) - return ret0, ret1 -} - -// DescribeAutomationExecutionsRequest indicates an expected call of DescribeAutomationExecutionsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationExecutionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationExecutionsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationExecutionsRequest), arg0) -} - -// DescribeAutomationExecutionsWithContext mocks base method. -func (m *MockSSMAPI) DescribeAutomationExecutionsWithContext(arg0 context.Context, arg1 *ssm.DescribeAutomationExecutionsInput, arg2 ...request.Option) (*ssm.DescribeAutomationExecutionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAutomationExecutionsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeAutomationExecutionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAutomationExecutionsWithContext indicates an expected call of DescribeAutomationExecutionsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationExecutionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationExecutionsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationExecutionsWithContext), varargs...) -} - -// DescribeAutomationStepExecutions mocks base method. -func (m *MockSSMAPI) DescribeAutomationStepExecutions(arg0 *ssm.DescribeAutomationStepExecutionsInput) (*ssm.DescribeAutomationStepExecutionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAutomationStepExecutions", arg0) - ret0, _ := ret[0].(*ssm.DescribeAutomationStepExecutionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAutomationStepExecutions indicates an expected call of DescribeAutomationStepExecutions. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationStepExecutions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationStepExecutions", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationStepExecutions), arg0) -} - -// DescribeAutomationStepExecutionsPages mocks base method. -func (m *MockSSMAPI) DescribeAutomationStepExecutionsPages(arg0 *ssm.DescribeAutomationStepExecutionsInput, arg1 func(*ssm.DescribeAutomationStepExecutionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAutomationStepExecutionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAutomationStepExecutionsPages indicates an expected call of DescribeAutomationStepExecutionsPages. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationStepExecutionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationStepExecutionsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationStepExecutionsPages), arg0, arg1) -} - -// DescribeAutomationStepExecutionsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeAutomationStepExecutionsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeAutomationStepExecutionsInput, arg2 func(*ssm.DescribeAutomationStepExecutionsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAutomationStepExecutionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAutomationStepExecutionsPagesWithContext indicates an expected call of DescribeAutomationStepExecutionsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationStepExecutionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationStepExecutionsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationStepExecutionsPagesWithContext), varargs...) -} - -// DescribeAutomationStepExecutionsRequest mocks base method. -func (m *MockSSMAPI) DescribeAutomationStepExecutionsRequest(arg0 *ssm.DescribeAutomationStepExecutionsInput) (*request.Request, *ssm.DescribeAutomationStepExecutionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAutomationStepExecutionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeAutomationStepExecutionsOutput) - return ret0, ret1 -} - -// DescribeAutomationStepExecutionsRequest indicates an expected call of DescribeAutomationStepExecutionsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationStepExecutionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationStepExecutionsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationStepExecutionsRequest), arg0) -} - -// DescribeAutomationStepExecutionsWithContext mocks base method. -func (m *MockSSMAPI) DescribeAutomationStepExecutionsWithContext(arg0 context.Context, arg1 *ssm.DescribeAutomationStepExecutionsInput, arg2 ...request.Option) (*ssm.DescribeAutomationStepExecutionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAutomationStepExecutionsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeAutomationStepExecutionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAutomationStepExecutionsWithContext indicates an expected call of DescribeAutomationStepExecutionsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAutomationStepExecutionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutomationStepExecutionsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAutomationStepExecutionsWithContext), varargs...) -} - -// DescribeAvailablePatches mocks base method. -func (m *MockSSMAPI) DescribeAvailablePatches(arg0 *ssm.DescribeAvailablePatchesInput) (*ssm.DescribeAvailablePatchesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAvailablePatches", arg0) - ret0, _ := ret[0].(*ssm.DescribeAvailablePatchesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAvailablePatches indicates an expected call of DescribeAvailablePatches. -func (mr *MockSSMAPIMockRecorder) DescribeAvailablePatches(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailablePatches", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAvailablePatches), arg0) -} - -// DescribeAvailablePatchesPages mocks base method. -func (m *MockSSMAPI) DescribeAvailablePatchesPages(arg0 *ssm.DescribeAvailablePatchesInput, arg1 func(*ssm.DescribeAvailablePatchesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAvailablePatchesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAvailablePatchesPages indicates an expected call of DescribeAvailablePatchesPages. -func (mr *MockSSMAPIMockRecorder) DescribeAvailablePatchesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailablePatchesPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAvailablePatchesPages), arg0, arg1) -} - -// DescribeAvailablePatchesPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeAvailablePatchesPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeAvailablePatchesInput, arg2 func(*ssm.DescribeAvailablePatchesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAvailablePatchesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAvailablePatchesPagesWithContext indicates an expected call of DescribeAvailablePatchesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAvailablePatchesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailablePatchesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAvailablePatchesPagesWithContext), varargs...) -} - -// DescribeAvailablePatchesRequest mocks base method. -func (m *MockSSMAPI) DescribeAvailablePatchesRequest(arg0 *ssm.DescribeAvailablePatchesInput) (*request.Request, *ssm.DescribeAvailablePatchesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAvailablePatchesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeAvailablePatchesOutput) - return ret0, ret1 -} - -// DescribeAvailablePatchesRequest indicates an expected call of DescribeAvailablePatchesRequest. -func (mr *MockSSMAPIMockRecorder) DescribeAvailablePatchesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailablePatchesRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAvailablePatchesRequest), arg0) -} - -// DescribeAvailablePatchesWithContext mocks base method. -func (m *MockSSMAPI) DescribeAvailablePatchesWithContext(arg0 context.Context, arg1 *ssm.DescribeAvailablePatchesInput, arg2 ...request.Option) (*ssm.DescribeAvailablePatchesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAvailablePatchesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeAvailablePatchesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAvailablePatchesWithContext indicates an expected call of DescribeAvailablePatchesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeAvailablePatchesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailablePatchesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeAvailablePatchesWithContext), varargs...) -} - -// DescribeDocument mocks base method. -func (m *MockSSMAPI) DescribeDocument(arg0 *ssm.DescribeDocumentInput) (*ssm.DescribeDocumentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDocument", arg0) - ret0, _ := ret[0].(*ssm.DescribeDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeDocument indicates an expected call of DescribeDocument. -func (mr *MockSSMAPIMockRecorder) DescribeDocument(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDocument", reflect.TypeOf((*MockSSMAPI)(nil).DescribeDocument), arg0) -} - -// DescribeDocumentPermission mocks base method. -func (m *MockSSMAPI) DescribeDocumentPermission(arg0 *ssm.DescribeDocumentPermissionInput) (*ssm.DescribeDocumentPermissionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDocumentPermission", arg0) - ret0, _ := ret[0].(*ssm.DescribeDocumentPermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeDocumentPermission indicates an expected call of DescribeDocumentPermission. -func (mr *MockSSMAPIMockRecorder) DescribeDocumentPermission(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDocumentPermission", reflect.TypeOf((*MockSSMAPI)(nil).DescribeDocumentPermission), arg0) -} - -// DescribeDocumentPermissionRequest mocks base method. -func (m *MockSSMAPI) DescribeDocumentPermissionRequest(arg0 *ssm.DescribeDocumentPermissionInput) (*request.Request, *ssm.DescribeDocumentPermissionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDocumentPermissionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeDocumentPermissionOutput) - return ret0, ret1 -} - -// DescribeDocumentPermissionRequest indicates an expected call of DescribeDocumentPermissionRequest. -func (mr *MockSSMAPIMockRecorder) DescribeDocumentPermissionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDocumentPermissionRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeDocumentPermissionRequest), arg0) -} - -// DescribeDocumentPermissionWithContext mocks base method. -func (m *MockSSMAPI) DescribeDocumentPermissionWithContext(arg0 context.Context, arg1 *ssm.DescribeDocumentPermissionInput, arg2 ...request.Option) (*ssm.DescribeDocumentPermissionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeDocumentPermissionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeDocumentPermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeDocumentPermissionWithContext indicates an expected call of DescribeDocumentPermissionWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeDocumentPermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDocumentPermissionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeDocumentPermissionWithContext), varargs...) -} - -// DescribeDocumentRequest mocks base method. -func (m *MockSSMAPI) DescribeDocumentRequest(arg0 *ssm.DescribeDocumentInput) (*request.Request, *ssm.DescribeDocumentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDocumentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeDocumentOutput) - return ret0, ret1 -} - -// DescribeDocumentRequest indicates an expected call of DescribeDocumentRequest. -func (mr *MockSSMAPIMockRecorder) DescribeDocumentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDocumentRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeDocumentRequest), arg0) -} - -// DescribeDocumentWithContext mocks base method. -func (m *MockSSMAPI) DescribeDocumentWithContext(arg0 context.Context, arg1 *ssm.DescribeDocumentInput, arg2 ...request.Option) (*ssm.DescribeDocumentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeDocumentWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeDocumentWithContext indicates an expected call of DescribeDocumentWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeDocumentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDocumentWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeDocumentWithContext), varargs...) -} - -// DescribeEffectiveInstanceAssociations mocks base method. -func (m *MockSSMAPI) DescribeEffectiveInstanceAssociations(arg0 *ssm.DescribeEffectiveInstanceAssociationsInput) (*ssm.DescribeEffectiveInstanceAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEffectiveInstanceAssociations", arg0) - ret0, _ := ret[0].(*ssm.DescribeEffectiveInstanceAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeEffectiveInstanceAssociations indicates an expected call of DescribeEffectiveInstanceAssociations. -func (mr *MockSSMAPIMockRecorder) DescribeEffectiveInstanceAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectiveInstanceAssociations", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectiveInstanceAssociations), arg0) -} - -// DescribeEffectiveInstanceAssociationsPages mocks base method. -func (m *MockSSMAPI) DescribeEffectiveInstanceAssociationsPages(arg0 *ssm.DescribeEffectiveInstanceAssociationsInput, arg1 func(*ssm.DescribeEffectiveInstanceAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEffectiveInstanceAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeEffectiveInstanceAssociationsPages indicates an expected call of DescribeEffectiveInstanceAssociationsPages. -func (mr *MockSSMAPIMockRecorder) DescribeEffectiveInstanceAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectiveInstanceAssociationsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectiveInstanceAssociationsPages), arg0, arg1) -} - -// DescribeEffectiveInstanceAssociationsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeEffectiveInstanceAssociationsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeEffectiveInstanceAssociationsInput, arg2 func(*ssm.DescribeEffectiveInstanceAssociationsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeEffectiveInstanceAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeEffectiveInstanceAssociationsPagesWithContext indicates an expected call of DescribeEffectiveInstanceAssociationsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeEffectiveInstanceAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectiveInstanceAssociationsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectiveInstanceAssociationsPagesWithContext), varargs...) -} - -// DescribeEffectiveInstanceAssociationsRequest mocks base method. -func (m *MockSSMAPI) DescribeEffectiveInstanceAssociationsRequest(arg0 *ssm.DescribeEffectiveInstanceAssociationsInput) (*request.Request, *ssm.DescribeEffectiveInstanceAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEffectiveInstanceAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeEffectiveInstanceAssociationsOutput) - return ret0, ret1 -} - -// DescribeEffectiveInstanceAssociationsRequest indicates an expected call of DescribeEffectiveInstanceAssociationsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeEffectiveInstanceAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectiveInstanceAssociationsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectiveInstanceAssociationsRequest), arg0) -} - -// DescribeEffectiveInstanceAssociationsWithContext mocks base method. -func (m *MockSSMAPI) DescribeEffectiveInstanceAssociationsWithContext(arg0 context.Context, arg1 *ssm.DescribeEffectiveInstanceAssociationsInput, arg2 ...request.Option) (*ssm.DescribeEffectiveInstanceAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeEffectiveInstanceAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeEffectiveInstanceAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeEffectiveInstanceAssociationsWithContext indicates an expected call of DescribeEffectiveInstanceAssociationsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeEffectiveInstanceAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectiveInstanceAssociationsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectiveInstanceAssociationsWithContext), varargs...) -} - -// DescribeEffectivePatchesForPatchBaseline mocks base method. -func (m *MockSSMAPI) DescribeEffectivePatchesForPatchBaseline(arg0 *ssm.DescribeEffectivePatchesForPatchBaselineInput) (*ssm.DescribeEffectivePatchesForPatchBaselineOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEffectivePatchesForPatchBaseline", arg0) - ret0, _ := ret[0].(*ssm.DescribeEffectivePatchesForPatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeEffectivePatchesForPatchBaseline indicates an expected call of DescribeEffectivePatchesForPatchBaseline. -func (mr *MockSSMAPIMockRecorder) DescribeEffectivePatchesForPatchBaseline(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectivePatchesForPatchBaseline", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectivePatchesForPatchBaseline), arg0) -} - -// DescribeEffectivePatchesForPatchBaselinePages mocks base method. -func (m *MockSSMAPI) DescribeEffectivePatchesForPatchBaselinePages(arg0 *ssm.DescribeEffectivePatchesForPatchBaselineInput, arg1 func(*ssm.DescribeEffectivePatchesForPatchBaselineOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEffectivePatchesForPatchBaselinePages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeEffectivePatchesForPatchBaselinePages indicates an expected call of DescribeEffectivePatchesForPatchBaselinePages. -func (mr *MockSSMAPIMockRecorder) DescribeEffectivePatchesForPatchBaselinePages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectivePatchesForPatchBaselinePages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectivePatchesForPatchBaselinePages), arg0, arg1) -} - -// DescribeEffectivePatchesForPatchBaselinePagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeEffectivePatchesForPatchBaselinePagesWithContext(arg0 context.Context, arg1 *ssm.DescribeEffectivePatchesForPatchBaselineInput, arg2 func(*ssm.DescribeEffectivePatchesForPatchBaselineOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeEffectivePatchesForPatchBaselinePagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeEffectivePatchesForPatchBaselinePagesWithContext indicates an expected call of DescribeEffectivePatchesForPatchBaselinePagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeEffectivePatchesForPatchBaselinePagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectivePatchesForPatchBaselinePagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectivePatchesForPatchBaselinePagesWithContext), varargs...) -} - -// DescribeEffectivePatchesForPatchBaselineRequest mocks base method. -func (m *MockSSMAPI) DescribeEffectivePatchesForPatchBaselineRequest(arg0 *ssm.DescribeEffectivePatchesForPatchBaselineInput) (*request.Request, *ssm.DescribeEffectivePatchesForPatchBaselineOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEffectivePatchesForPatchBaselineRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeEffectivePatchesForPatchBaselineOutput) - return ret0, ret1 -} - -// DescribeEffectivePatchesForPatchBaselineRequest indicates an expected call of DescribeEffectivePatchesForPatchBaselineRequest. -func (mr *MockSSMAPIMockRecorder) DescribeEffectivePatchesForPatchBaselineRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectivePatchesForPatchBaselineRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectivePatchesForPatchBaselineRequest), arg0) -} - -// DescribeEffectivePatchesForPatchBaselineWithContext mocks base method. -func (m *MockSSMAPI) DescribeEffectivePatchesForPatchBaselineWithContext(arg0 context.Context, arg1 *ssm.DescribeEffectivePatchesForPatchBaselineInput, arg2 ...request.Option) (*ssm.DescribeEffectivePatchesForPatchBaselineOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeEffectivePatchesForPatchBaselineWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeEffectivePatchesForPatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeEffectivePatchesForPatchBaselineWithContext indicates an expected call of DescribeEffectivePatchesForPatchBaselineWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeEffectivePatchesForPatchBaselineWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEffectivePatchesForPatchBaselineWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeEffectivePatchesForPatchBaselineWithContext), varargs...) -} - -// DescribeInstanceAssociationsStatus mocks base method. -func (m *MockSSMAPI) DescribeInstanceAssociationsStatus(arg0 *ssm.DescribeInstanceAssociationsStatusInput) (*ssm.DescribeInstanceAssociationsStatusOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceAssociationsStatus", arg0) - ret0, _ := ret[0].(*ssm.DescribeInstanceAssociationsStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceAssociationsStatus indicates an expected call of DescribeInstanceAssociationsStatus. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceAssociationsStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAssociationsStatus", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceAssociationsStatus), arg0) -} - -// DescribeInstanceAssociationsStatusPages mocks base method. -func (m *MockSSMAPI) DescribeInstanceAssociationsStatusPages(arg0 *ssm.DescribeInstanceAssociationsStatusInput, arg1 func(*ssm.DescribeInstanceAssociationsStatusOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceAssociationsStatusPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceAssociationsStatusPages indicates an expected call of DescribeInstanceAssociationsStatusPages. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceAssociationsStatusPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAssociationsStatusPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceAssociationsStatusPages), arg0, arg1) -} - -// DescribeInstanceAssociationsStatusPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstanceAssociationsStatusPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstanceAssociationsStatusInput, arg2 func(*ssm.DescribeInstanceAssociationsStatusOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceAssociationsStatusPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceAssociationsStatusPagesWithContext indicates an expected call of DescribeInstanceAssociationsStatusPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceAssociationsStatusPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAssociationsStatusPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceAssociationsStatusPagesWithContext), varargs...) -} - -// DescribeInstanceAssociationsStatusRequest mocks base method. -func (m *MockSSMAPI) DescribeInstanceAssociationsStatusRequest(arg0 *ssm.DescribeInstanceAssociationsStatusInput) (*request.Request, *ssm.DescribeInstanceAssociationsStatusOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceAssociationsStatusRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeInstanceAssociationsStatusOutput) - return ret0, ret1 -} - -// DescribeInstanceAssociationsStatusRequest indicates an expected call of DescribeInstanceAssociationsStatusRequest. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceAssociationsStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAssociationsStatusRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceAssociationsStatusRequest), arg0) -} - -// DescribeInstanceAssociationsStatusWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstanceAssociationsStatusWithContext(arg0 context.Context, arg1 *ssm.DescribeInstanceAssociationsStatusInput, arg2 ...request.Option) (*ssm.DescribeInstanceAssociationsStatusOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceAssociationsStatusWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeInstanceAssociationsStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceAssociationsStatusWithContext indicates an expected call of DescribeInstanceAssociationsStatusWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceAssociationsStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAssociationsStatusWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceAssociationsStatusWithContext), varargs...) -} - -// DescribeInstanceInformation mocks base method. -func (m *MockSSMAPI) DescribeInstanceInformation(arg0 *ssm.DescribeInstanceInformationInput) (*ssm.DescribeInstanceInformationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceInformation", arg0) - ret0, _ := ret[0].(*ssm.DescribeInstanceInformationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceInformation indicates an expected call of DescribeInstanceInformation. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceInformation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceInformation", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceInformation), arg0) -} - -// DescribeInstanceInformationPages mocks base method. -func (m *MockSSMAPI) DescribeInstanceInformationPages(arg0 *ssm.DescribeInstanceInformationInput, arg1 func(*ssm.DescribeInstanceInformationOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceInformationPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceInformationPages indicates an expected call of DescribeInstanceInformationPages. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceInformationPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceInformationPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceInformationPages), arg0, arg1) -} - -// DescribeInstanceInformationPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstanceInformationPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstanceInformationInput, arg2 func(*ssm.DescribeInstanceInformationOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceInformationPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceInformationPagesWithContext indicates an expected call of DescribeInstanceInformationPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceInformationPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceInformationPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceInformationPagesWithContext), varargs...) -} - -// DescribeInstanceInformationRequest mocks base method. -func (m *MockSSMAPI) DescribeInstanceInformationRequest(arg0 *ssm.DescribeInstanceInformationInput) (*request.Request, *ssm.DescribeInstanceInformationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceInformationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeInstanceInformationOutput) - return ret0, ret1 -} - -// DescribeInstanceInformationRequest indicates an expected call of DescribeInstanceInformationRequest. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceInformationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceInformationRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceInformationRequest), arg0) -} - -// DescribeInstanceInformationWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstanceInformationWithContext(arg0 context.Context, arg1 *ssm.DescribeInstanceInformationInput, arg2 ...request.Option) (*ssm.DescribeInstanceInformationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceInformationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeInstanceInformationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceInformationWithContext indicates an expected call of DescribeInstanceInformationWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceInformationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceInformationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceInformationWithContext), varargs...) -} - -// DescribeInstancePatchStates mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStates(arg0 *ssm.DescribeInstancePatchStatesInput) (*ssm.DescribeInstancePatchStatesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatchStates", arg0) - ret0, _ := ret[0].(*ssm.DescribeInstancePatchStatesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancePatchStates indicates an expected call of DescribeInstancePatchStates. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStates(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStates", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStates), arg0) -} - -// DescribeInstancePatchStatesForPatchGroup mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesForPatchGroup(arg0 *ssm.DescribeInstancePatchStatesForPatchGroupInput) (*ssm.DescribeInstancePatchStatesForPatchGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesForPatchGroup", arg0) - ret0, _ := ret[0].(*ssm.DescribeInstancePatchStatesForPatchGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancePatchStatesForPatchGroup indicates an expected call of DescribeInstancePatchStatesForPatchGroup. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesForPatchGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesForPatchGroup", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesForPatchGroup), arg0) -} - -// DescribeInstancePatchStatesForPatchGroupPages mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesForPatchGroupPages(arg0 *ssm.DescribeInstancePatchStatesForPatchGroupInput, arg1 func(*ssm.DescribeInstancePatchStatesForPatchGroupOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesForPatchGroupPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancePatchStatesForPatchGroupPages indicates an expected call of DescribeInstancePatchStatesForPatchGroupPages. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesForPatchGroupPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesForPatchGroupPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesForPatchGroupPages), arg0, arg1) -} - -// DescribeInstancePatchStatesForPatchGroupPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesForPatchGroupPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePatchStatesForPatchGroupInput, arg2 func(*ssm.DescribeInstancePatchStatesForPatchGroupOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesForPatchGroupPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancePatchStatesForPatchGroupPagesWithContext indicates an expected call of DescribeInstancePatchStatesForPatchGroupPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesForPatchGroupPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesForPatchGroupPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesForPatchGroupPagesWithContext), varargs...) -} - -// DescribeInstancePatchStatesForPatchGroupRequest mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesForPatchGroupRequest(arg0 *ssm.DescribeInstancePatchStatesForPatchGroupInput) (*request.Request, *ssm.DescribeInstancePatchStatesForPatchGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesForPatchGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeInstancePatchStatesForPatchGroupOutput) - return ret0, ret1 -} - -// DescribeInstancePatchStatesForPatchGroupRequest indicates an expected call of DescribeInstancePatchStatesForPatchGroupRequest. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesForPatchGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesForPatchGroupRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesForPatchGroupRequest), arg0) -} - -// DescribeInstancePatchStatesForPatchGroupWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesForPatchGroupWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePatchStatesForPatchGroupInput, arg2 ...request.Option) (*ssm.DescribeInstancePatchStatesForPatchGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesForPatchGroupWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeInstancePatchStatesForPatchGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancePatchStatesForPatchGroupWithContext indicates an expected call of DescribeInstancePatchStatesForPatchGroupWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesForPatchGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesForPatchGroupWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesForPatchGroupWithContext), varargs...) -} - -// DescribeInstancePatchStatesPages mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesPages(arg0 *ssm.DescribeInstancePatchStatesInput, arg1 func(*ssm.DescribeInstancePatchStatesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancePatchStatesPages indicates an expected call of DescribeInstancePatchStatesPages. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesPages), arg0, arg1) -} - -// DescribeInstancePatchStatesPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePatchStatesInput, arg2 func(*ssm.DescribeInstancePatchStatesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancePatchStatesPagesWithContext indicates an expected call of DescribeInstancePatchStatesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesPagesWithContext), varargs...) -} - -// DescribeInstancePatchStatesRequest mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesRequest(arg0 *ssm.DescribeInstancePatchStatesInput) (*request.Request, *ssm.DescribeInstancePatchStatesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeInstancePatchStatesOutput) - return ret0, ret1 -} - -// DescribeInstancePatchStatesRequest indicates an expected call of DescribeInstancePatchStatesRequest. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesRequest), arg0) -} - -// DescribeInstancePatchStatesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchStatesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePatchStatesInput, arg2 ...request.Option) (*ssm.DescribeInstancePatchStatesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancePatchStatesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeInstancePatchStatesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancePatchStatesWithContext indicates an expected call of DescribeInstancePatchStatesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchStatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchStatesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchStatesWithContext), varargs...) -} - -// DescribeInstancePatches mocks base method. -func (m *MockSSMAPI) DescribeInstancePatches(arg0 *ssm.DescribeInstancePatchesInput) (*ssm.DescribeInstancePatchesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatches", arg0) - ret0, _ := ret[0].(*ssm.DescribeInstancePatchesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancePatches indicates an expected call of DescribeInstancePatches. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatches(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatches", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatches), arg0) -} - -// DescribeInstancePatchesPages mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchesPages(arg0 *ssm.DescribeInstancePatchesInput, arg1 func(*ssm.DescribeInstancePatchesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatchesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancePatchesPages indicates an expected call of DescribeInstancePatchesPages. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchesPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchesPages), arg0, arg1) -} - -// DescribeInstancePatchesPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchesPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePatchesInput, arg2 func(*ssm.DescribeInstancePatchesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancePatchesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancePatchesPagesWithContext indicates an expected call of DescribeInstancePatchesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchesPagesWithContext), varargs...) -} - -// DescribeInstancePatchesRequest mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchesRequest(arg0 *ssm.DescribeInstancePatchesInput) (*request.Request, *ssm.DescribeInstancePatchesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePatchesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeInstancePatchesOutput) - return ret0, ret1 -} - -// DescribeInstancePatchesRequest indicates an expected call of DescribeInstancePatchesRequest. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchesRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchesRequest), arg0) -} - -// DescribeInstancePatchesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstancePatchesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePatchesInput, arg2 ...request.Option) (*ssm.DescribeInstancePatchesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancePatchesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeInstancePatchesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancePatchesWithContext indicates an expected call of DescribeInstancePatchesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePatchesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePatchesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePatchesWithContext), varargs...) -} - -// DescribeInstanceProperties mocks base method. -func (m *MockSSMAPI) DescribeInstanceProperties(arg0 *ssm.DescribeInstancePropertiesInput) (*ssm.DescribeInstancePropertiesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceProperties", arg0) - ret0, _ := ret[0].(*ssm.DescribeInstancePropertiesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceProperties indicates an expected call of DescribeInstanceProperties. -func (mr *MockSSMAPIMockRecorder) DescribeInstanceProperties(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceProperties", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstanceProperties), arg0) -} - -// DescribeInstancePropertiesPages mocks base method. -func (m *MockSSMAPI) DescribeInstancePropertiesPages(arg0 *ssm.DescribeInstancePropertiesInput, arg1 func(*ssm.DescribeInstancePropertiesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePropertiesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancePropertiesPages indicates an expected call of DescribeInstancePropertiesPages. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePropertiesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePropertiesPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePropertiesPages), arg0, arg1) -} - -// DescribeInstancePropertiesPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstancePropertiesPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePropertiesInput, arg2 func(*ssm.DescribeInstancePropertiesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancePropertiesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancePropertiesPagesWithContext indicates an expected call of DescribeInstancePropertiesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePropertiesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePropertiesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePropertiesPagesWithContext), varargs...) -} - -// DescribeInstancePropertiesRequest mocks base method. -func (m *MockSSMAPI) DescribeInstancePropertiesRequest(arg0 *ssm.DescribeInstancePropertiesInput) (*request.Request, *ssm.DescribeInstancePropertiesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancePropertiesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeInstancePropertiesOutput) - return ret0, ret1 -} - -// DescribeInstancePropertiesRequest indicates an expected call of DescribeInstancePropertiesRequest. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePropertiesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePropertiesRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePropertiesRequest), arg0) -} - -// DescribeInstancePropertiesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInstancePropertiesWithContext(arg0 context.Context, arg1 *ssm.DescribeInstancePropertiesInput, arg2 ...request.Option) (*ssm.DescribeInstancePropertiesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancePropertiesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeInstancePropertiesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancePropertiesWithContext indicates an expected call of DescribeInstancePropertiesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInstancePropertiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancePropertiesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInstancePropertiesWithContext), varargs...) -} - -// DescribeInventoryDeletions mocks base method. -func (m *MockSSMAPI) DescribeInventoryDeletions(arg0 *ssm.DescribeInventoryDeletionsInput) (*ssm.DescribeInventoryDeletionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInventoryDeletions", arg0) - ret0, _ := ret[0].(*ssm.DescribeInventoryDeletionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInventoryDeletions indicates an expected call of DescribeInventoryDeletions. -func (mr *MockSSMAPIMockRecorder) DescribeInventoryDeletions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInventoryDeletions", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInventoryDeletions), arg0) -} - -// DescribeInventoryDeletionsPages mocks base method. -func (m *MockSSMAPI) DescribeInventoryDeletionsPages(arg0 *ssm.DescribeInventoryDeletionsInput, arg1 func(*ssm.DescribeInventoryDeletionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInventoryDeletionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInventoryDeletionsPages indicates an expected call of DescribeInventoryDeletionsPages. -func (mr *MockSSMAPIMockRecorder) DescribeInventoryDeletionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInventoryDeletionsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInventoryDeletionsPages), arg0, arg1) -} - -// DescribeInventoryDeletionsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeInventoryDeletionsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeInventoryDeletionsInput, arg2 func(*ssm.DescribeInventoryDeletionsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInventoryDeletionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInventoryDeletionsPagesWithContext indicates an expected call of DescribeInventoryDeletionsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInventoryDeletionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInventoryDeletionsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInventoryDeletionsPagesWithContext), varargs...) -} - -// DescribeInventoryDeletionsRequest mocks base method. -func (m *MockSSMAPI) DescribeInventoryDeletionsRequest(arg0 *ssm.DescribeInventoryDeletionsInput) (*request.Request, *ssm.DescribeInventoryDeletionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInventoryDeletionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeInventoryDeletionsOutput) - return ret0, ret1 -} - -// DescribeInventoryDeletionsRequest indicates an expected call of DescribeInventoryDeletionsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeInventoryDeletionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInventoryDeletionsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInventoryDeletionsRequest), arg0) -} - -// DescribeInventoryDeletionsWithContext mocks base method. -func (m *MockSSMAPI) DescribeInventoryDeletionsWithContext(arg0 context.Context, arg1 *ssm.DescribeInventoryDeletionsInput, arg2 ...request.Option) (*ssm.DescribeInventoryDeletionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInventoryDeletionsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeInventoryDeletionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInventoryDeletionsWithContext indicates an expected call of DescribeInventoryDeletionsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeInventoryDeletionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInventoryDeletionsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeInventoryDeletionsWithContext), varargs...) -} - -// DescribeMaintenanceWindowExecutionTaskInvocations mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTaskInvocations(arg0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) (*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTaskInvocations", arg0) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutionTaskInvocations indicates an expected call of DescribeMaintenanceWindowExecutionTaskInvocations. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTaskInvocations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTaskInvocations", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTaskInvocations), arg0) -} - -// DescribeMaintenanceWindowExecutionTaskInvocationsPages mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsPages(arg0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, arg1 func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTaskInvocationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowExecutionTaskInvocationsPages indicates an expected call of DescribeMaintenanceWindowExecutionTaskInvocationsPages. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTaskInvocationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTaskInvocationsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTaskInvocationsPages), arg0, arg1) -} - -// DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, arg2 func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext indicates an expected call of DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext), varargs...) -} - -// DescribeMaintenanceWindowExecutionTaskInvocationsRequest mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsRequest(arg0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTaskInvocationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutionTaskInvocationsRequest indicates an expected call of DescribeMaintenanceWindowExecutionTaskInvocationsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTaskInvocationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTaskInvocationsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTaskInvocationsRequest), arg0) -} - -// DescribeMaintenanceWindowExecutionTaskInvocationsWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, arg2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTaskInvocationsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutionTaskInvocationsWithContext indicates an expected call of DescribeMaintenanceWindowExecutionTaskInvocationsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTaskInvocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTaskInvocationsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTaskInvocationsWithContext), varargs...) -} - -// DescribeMaintenanceWindowExecutionTasks mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTasks(arg0 *ssm.DescribeMaintenanceWindowExecutionTasksInput) (*ssm.DescribeMaintenanceWindowExecutionTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTasks", arg0) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowExecutionTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutionTasks indicates an expected call of DescribeMaintenanceWindowExecutionTasks. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTasks", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTasks), arg0) -} - -// DescribeMaintenanceWindowExecutionTasksPages mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTasksPages(arg0 *ssm.DescribeMaintenanceWindowExecutionTasksInput, arg1 func(*ssm.DescribeMaintenanceWindowExecutionTasksOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTasksPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowExecutionTasksPages indicates an expected call of DescribeMaintenanceWindowExecutionTasksPages. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTasksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTasksPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTasksPages), arg0, arg1) -} - -// DescribeMaintenanceWindowExecutionTasksPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTasksPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowExecutionTasksInput, arg2 func(*ssm.DescribeMaintenanceWindowExecutionTasksOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTasksPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowExecutionTasksPagesWithContext indicates an expected call of DescribeMaintenanceWindowExecutionTasksPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTasksPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTasksPagesWithContext), varargs...) -} - -// DescribeMaintenanceWindowExecutionTasksRequest mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTasksRequest(arg0 *ssm.DescribeMaintenanceWindowExecutionTasksInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeMaintenanceWindowExecutionTasksOutput) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutionTasksRequest indicates an expected call of DescribeMaintenanceWindowExecutionTasksRequest. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTasksRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTasksRequest), arg0) -} - -// DescribeMaintenanceWindowExecutionTasksWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionTasksWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowExecutionTasksInput, arg2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionTasksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionTasksWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowExecutionTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutionTasksWithContext indicates an expected call of DescribeMaintenanceWindowExecutionTasksWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionTasksWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionTasksWithContext), varargs...) -} - -// DescribeMaintenanceWindowExecutions mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutions(arg0 *ssm.DescribeMaintenanceWindowExecutionsInput) (*ssm.DescribeMaintenanceWindowExecutionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutions", arg0) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowExecutionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutions indicates an expected call of DescribeMaintenanceWindowExecutions. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutions", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutions), arg0) -} - -// DescribeMaintenanceWindowExecutionsPages mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionsPages(arg0 *ssm.DescribeMaintenanceWindowExecutionsInput, arg1 func(*ssm.DescribeMaintenanceWindowExecutionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowExecutionsPages indicates an expected call of DescribeMaintenanceWindowExecutionsPages. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionsPages), arg0, arg1) -} - -// DescribeMaintenanceWindowExecutionsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowExecutionsInput, arg2 func(*ssm.DescribeMaintenanceWindowExecutionsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowExecutionsPagesWithContext indicates an expected call of DescribeMaintenanceWindowExecutionsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionsPagesWithContext), varargs...) -} - -// DescribeMaintenanceWindowExecutionsRequest mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionsRequest(arg0 *ssm.DescribeMaintenanceWindowExecutionsInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeMaintenanceWindowExecutionsOutput) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutionsRequest indicates an expected call of DescribeMaintenanceWindowExecutionsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionsRequest), arg0) -} - -// DescribeMaintenanceWindowExecutionsWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowExecutionsWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowExecutionsInput, arg2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowExecutionsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowExecutionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowExecutionsWithContext indicates an expected call of DescribeMaintenanceWindowExecutionsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowExecutionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowExecutionsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowExecutionsWithContext), varargs...) -} - -// DescribeMaintenanceWindowSchedule mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowSchedule(arg0 *ssm.DescribeMaintenanceWindowScheduleInput) (*ssm.DescribeMaintenanceWindowScheduleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowSchedule", arg0) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowScheduleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowSchedule indicates an expected call of DescribeMaintenanceWindowSchedule. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowSchedule(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowSchedule", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowSchedule), arg0) -} - -// DescribeMaintenanceWindowSchedulePages mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowSchedulePages(arg0 *ssm.DescribeMaintenanceWindowScheduleInput, arg1 func(*ssm.DescribeMaintenanceWindowScheduleOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowSchedulePages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowSchedulePages indicates an expected call of DescribeMaintenanceWindowSchedulePages. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowSchedulePages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowSchedulePages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowSchedulePages), arg0, arg1) -} - -// DescribeMaintenanceWindowSchedulePagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowSchedulePagesWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowScheduleInput, arg2 func(*ssm.DescribeMaintenanceWindowScheduleOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowSchedulePagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowSchedulePagesWithContext indicates an expected call of DescribeMaintenanceWindowSchedulePagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowSchedulePagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowSchedulePagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowSchedulePagesWithContext), varargs...) -} - -// DescribeMaintenanceWindowScheduleRequest mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowScheduleRequest(arg0 *ssm.DescribeMaintenanceWindowScheduleInput) (*request.Request, *ssm.DescribeMaintenanceWindowScheduleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowScheduleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeMaintenanceWindowScheduleOutput) - return ret0, ret1 -} - -// DescribeMaintenanceWindowScheduleRequest indicates an expected call of DescribeMaintenanceWindowScheduleRequest. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowScheduleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowScheduleRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowScheduleRequest), arg0) -} - -// DescribeMaintenanceWindowScheduleWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowScheduleWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowScheduleInput, arg2 ...request.Option) (*ssm.DescribeMaintenanceWindowScheduleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowScheduleWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowScheduleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowScheduleWithContext indicates an expected call of DescribeMaintenanceWindowScheduleWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowScheduleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowScheduleWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowScheduleWithContext), varargs...) -} - -// DescribeMaintenanceWindowTargets mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTargets(arg0 *ssm.DescribeMaintenanceWindowTargetsInput) (*ssm.DescribeMaintenanceWindowTargetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTargets", arg0) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowTargetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowTargets indicates an expected call of DescribeMaintenanceWindowTargets. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTargets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTargets", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTargets), arg0) -} - -// DescribeMaintenanceWindowTargetsPages mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTargetsPages(arg0 *ssm.DescribeMaintenanceWindowTargetsInput, arg1 func(*ssm.DescribeMaintenanceWindowTargetsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTargetsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowTargetsPages indicates an expected call of DescribeMaintenanceWindowTargetsPages. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTargetsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTargetsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTargetsPages), arg0, arg1) -} - -// DescribeMaintenanceWindowTargetsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTargetsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowTargetsInput, arg2 func(*ssm.DescribeMaintenanceWindowTargetsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTargetsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowTargetsPagesWithContext indicates an expected call of DescribeMaintenanceWindowTargetsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTargetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTargetsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTargetsPagesWithContext), varargs...) -} - -// DescribeMaintenanceWindowTargetsRequest mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTargetsRequest(arg0 *ssm.DescribeMaintenanceWindowTargetsInput) (*request.Request, *ssm.DescribeMaintenanceWindowTargetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTargetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeMaintenanceWindowTargetsOutput) - return ret0, ret1 -} - -// DescribeMaintenanceWindowTargetsRequest indicates an expected call of DescribeMaintenanceWindowTargetsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTargetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTargetsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTargetsRequest), arg0) -} - -// DescribeMaintenanceWindowTargetsWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTargetsWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowTargetsInput, arg2 ...request.Option) (*ssm.DescribeMaintenanceWindowTargetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTargetsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowTargetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowTargetsWithContext indicates an expected call of DescribeMaintenanceWindowTargetsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTargetsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTargetsWithContext), varargs...) -} - -// DescribeMaintenanceWindowTasks mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTasks(arg0 *ssm.DescribeMaintenanceWindowTasksInput) (*ssm.DescribeMaintenanceWindowTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTasks", arg0) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowTasks indicates an expected call of DescribeMaintenanceWindowTasks. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTasks", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTasks), arg0) -} - -// DescribeMaintenanceWindowTasksPages mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTasksPages(arg0 *ssm.DescribeMaintenanceWindowTasksInput, arg1 func(*ssm.DescribeMaintenanceWindowTasksOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTasksPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowTasksPages indicates an expected call of DescribeMaintenanceWindowTasksPages. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTasksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTasksPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTasksPages), arg0, arg1) -} - -// DescribeMaintenanceWindowTasksPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTasksPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowTasksInput, arg2 func(*ssm.DescribeMaintenanceWindowTasksOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTasksPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowTasksPagesWithContext indicates an expected call of DescribeMaintenanceWindowTasksPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTasksPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTasksPagesWithContext), varargs...) -} - -// DescribeMaintenanceWindowTasksRequest mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTasksRequest(arg0 *ssm.DescribeMaintenanceWindowTasksInput) (*request.Request, *ssm.DescribeMaintenanceWindowTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeMaintenanceWindowTasksOutput) - return ret0, ret1 -} - -// DescribeMaintenanceWindowTasksRequest indicates an expected call of DescribeMaintenanceWindowTasksRequest. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTasksRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTasksRequest), arg0) -} - -// DescribeMaintenanceWindowTasksWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowTasksWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowTasksInput, arg2 ...request.Option) (*ssm.DescribeMaintenanceWindowTasksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowTasksWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowTasksWithContext indicates an expected call of DescribeMaintenanceWindowTasksWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowTasksWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowTasksWithContext), varargs...) -} - -// DescribeMaintenanceWindows mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindows(arg0 *ssm.DescribeMaintenanceWindowsInput) (*ssm.DescribeMaintenanceWindowsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindows", arg0) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindows indicates an expected call of DescribeMaintenanceWindows. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindows(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindows", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindows), arg0) -} - -// DescribeMaintenanceWindowsForTarget mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsForTarget(arg0 *ssm.DescribeMaintenanceWindowsForTargetInput) (*ssm.DescribeMaintenanceWindowsForTargetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsForTarget", arg0) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowsForTargetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowsForTarget indicates an expected call of DescribeMaintenanceWindowsForTarget. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsForTarget(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsForTarget", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsForTarget), arg0) -} - -// DescribeMaintenanceWindowsForTargetPages mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsForTargetPages(arg0 *ssm.DescribeMaintenanceWindowsForTargetInput, arg1 func(*ssm.DescribeMaintenanceWindowsForTargetOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsForTargetPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowsForTargetPages indicates an expected call of DescribeMaintenanceWindowsForTargetPages. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsForTargetPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsForTargetPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsForTargetPages), arg0, arg1) -} - -// DescribeMaintenanceWindowsForTargetPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsForTargetPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowsForTargetInput, arg2 func(*ssm.DescribeMaintenanceWindowsForTargetOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsForTargetPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowsForTargetPagesWithContext indicates an expected call of DescribeMaintenanceWindowsForTargetPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsForTargetPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsForTargetPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsForTargetPagesWithContext), varargs...) -} - -// DescribeMaintenanceWindowsForTargetRequest mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsForTargetRequest(arg0 *ssm.DescribeMaintenanceWindowsForTargetInput) (*request.Request, *ssm.DescribeMaintenanceWindowsForTargetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsForTargetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeMaintenanceWindowsForTargetOutput) - return ret0, ret1 -} - -// DescribeMaintenanceWindowsForTargetRequest indicates an expected call of DescribeMaintenanceWindowsForTargetRequest. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsForTargetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsForTargetRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsForTargetRequest), arg0) -} - -// DescribeMaintenanceWindowsForTargetWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsForTargetWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowsForTargetInput, arg2 ...request.Option) (*ssm.DescribeMaintenanceWindowsForTargetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsForTargetWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowsForTargetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowsForTargetWithContext indicates an expected call of DescribeMaintenanceWindowsForTargetWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsForTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsForTargetWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsForTargetWithContext), varargs...) -} - -// DescribeMaintenanceWindowsPages mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsPages(arg0 *ssm.DescribeMaintenanceWindowsInput, arg1 func(*ssm.DescribeMaintenanceWindowsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowsPages indicates an expected call of DescribeMaintenanceWindowsPages. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsPages), arg0, arg1) -} - -// DescribeMaintenanceWindowsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowsInput, arg2 func(*ssm.DescribeMaintenanceWindowsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMaintenanceWindowsPagesWithContext indicates an expected call of DescribeMaintenanceWindowsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsPagesWithContext), varargs...) -} - -// DescribeMaintenanceWindowsRequest mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsRequest(arg0 *ssm.DescribeMaintenanceWindowsInput) (*request.Request, *ssm.DescribeMaintenanceWindowsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeMaintenanceWindowsOutput) - return ret0, ret1 -} - -// DescribeMaintenanceWindowsRequest indicates an expected call of DescribeMaintenanceWindowsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsRequest), arg0) -} - -// DescribeMaintenanceWindowsWithContext mocks base method. -func (m *MockSSMAPI) DescribeMaintenanceWindowsWithContext(arg0 context.Context, arg1 *ssm.DescribeMaintenanceWindowsInput, arg2 ...request.Option) (*ssm.DescribeMaintenanceWindowsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMaintenanceWindowsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeMaintenanceWindowsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMaintenanceWindowsWithContext indicates an expected call of DescribeMaintenanceWindowsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeMaintenanceWindowsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMaintenanceWindowsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeMaintenanceWindowsWithContext), varargs...) -} - -// DescribeOpsItems mocks base method. -func (m *MockSSMAPI) DescribeOpsItems(arg0 *ssm.DescribeOpsItemsInput) (*ssm.DescribeOpsItemsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeOpsItems", arg0) - ret0, _ := ret[0].(*ssm.DescribeOpsItemsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeOpsItems indicates an expected call of DescribeOpsItems. -func (mr *MockSSMAPIMockRecorder) DescribeOpsItems(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOpsItems", reflect.TypeOf((*MockSSMAPI)(nil).DescribeOpsItems), arg0) -} - -// DescribeOpsItemsPages mocks base method. -func (m *MockSSMAPI) DescribeOpsItemsPages(arg0 *ssm.DescribeOpsItemsInput, arg1 func(*ssm.DescribeOpsItemsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeOpsItemsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeOpsItemsPages indicates an expected call of DescribeOpsItemsPages. -func (mr *MockSSMAPIMockRecorder) DescribeOpsItemsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOpsItemsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeOpsItemsPages), arg0, arg1) -} - -// DescribeOpsItemsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeOpsItemsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeOpsItemsInput, arg2 func(*ssm.DescribeOpsItemsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeOpsItemsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeOpsItemsPagesWithContext indicates an expected call of DescribeOpsItemsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeOpsItemsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOpsItemsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeOpsItemsPagesWithContext), varargs...) -} - -// DescribeOpsItemsRequest mocks base method. -func (m *MockSSMAPI) DescribeOpsItemsRequest(arg0 *ssm.DescribeOpsItemsInput) (*request.Request, *ssm.DescribeOpsItemsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeOpsItemsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeOpsItemsOutput) - return ret0, ret1 -} - -// DescribeOpsItemsRequest indicates an expected call of DescribeOpsItemsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeOpsItemsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOpsItemsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeOpsItemsRequest), arg0) -} - -// DescribeOpsItemsWithContext mocks base method. -func (m *MockSSMAPI) DescribeOpsItemsWithContext(arg0 context.Context, arg1 *ssm.DescribeOpsItemsInput, arg2 ...request.Option) (*ssm.DescribeOpsItemsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeOpsItemsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeOpsItemsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeOpsItemsWithContext indicates an expected call of DescribeOpsItemsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeOpsItemsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOpsItemsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeOpsItemsWithContext), varargs...) -} - -// DescribeParameters mocks base method. -func (m *MockSSMAPI) DescribeParameters(arg0 *ssm.DescribeParametersInput) (*ssm.DescribeParametersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeParameters", arg0) - ret0, _ := ret[0].(*ssm.DescribeParametersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeParameters indicates an expected call of DescribeParameters. -func (mr *MockSSMAPIMockRecorder) DescribeParameters(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeParameters", reflect.TypeOf((*MockSSMAPI)(nil).DescribeParameters), arg0) -} - -// DescribeParametersPages mocks base method. -func (m *MockSSMAPI) DescribeParametersPages(arg0 *ssm.DescribeParametersInput, arg1 func(*ssm.DescribeParametersOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeParametersPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeParametersPages indicates an expected call of DescribeParametersPages. -func (mr *MockSSMAPIMockRecorder) DescribeParametersPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeParametersPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeParametersPages), arg0, arg1) -} - -// DescribeParametersPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeParametersPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeParametersInput, arg2 func(*ssm.DescribeParametersOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeParametersPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeParametersPagesWithContext indicates an expected call of DescribeParametersPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeParametersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeParametersPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeParametersPagesWithContext), varargs...) -} - -// DescribeParametersRequest mocks base method. -func (m *MockSSMAPI) DescribeParametersRequest(arg0 *ssm.DescribeParametersInput) (*request.Request, *ssm.DescribeParametersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeParametersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeParametersOutput) - return ret0, ret1 -} - -// DescribeParametersRequest indicates an expected call of DescribeParametersRequest. -func (mr *MockSSMAPIMockRecorder) DescribeParametersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeParametersRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeParametersRequest), arg0) -} - -// DescribeParametersWithContext mocks base method. -func (m *MockSSMAPI) DescribeParametersWithContext(arg0 context.Context, arg1 *ssm.DescribeParametersInput, arg2 ...request.Option) (*ssm.DescribeParametersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeParametersWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeParametersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeParametersWithContext indicates an expected call of DescribeParametersWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeParametersWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeParametersWithContext), varargs...) -} - -// DescribePatchBaselines mocks base method. -func (m *MockSSMAPI) DescribePatchBaselines(arg0 *ssm.DescribePatchBaselinesInput) (*ssm.DescribePatchBaselinesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchBaselines", arg0) - ret0, _ := ret[0].(*ssm.DescribePatchBaselinesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePatchBaselines indicates an expected call of DescribePatchBaselines. -func (mr *MockSSMAPIMockRecorder) DescribePatchBaselines(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchBaselines", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchBaselines), arg0) -} - -// DescribePatchBaselinesPages mocks base method. -func (m *MockSSMAPI) DescribePatchBaselinesPages(arg0 *ssm.DescribePatchBaselinesInput, arg1 func(*ssm.DescribePatchBaselinesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchBaselinesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePatchBaselinesPages indicates an expected call of DescribePatchBaselinesPages. -func (mr *MockSSMAPIMockRecorder) DescribePatchBaselinesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchBaselinesPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchBaselinesPages), arg0, arg1) -} - -// DescribePatchBaselinesPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribePatchBaselinesPagesWithContext(arg0 context.Context, arg1 *ssm.DescribePatchBaselinesInput, arg2 func(*ssm.DescribePatchBaselinesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePatchBaselinesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePatchBaselinesPagesWithContext indicates an expected call of DescribePatchBaselinesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribePatchBaselinesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchBaselinesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchBaselinesPagesWithContext), varargs...) -} - -// DescribePatchBaselinesRequest mocks base method. -func (m *MockSSMAPI) DescribePatchBaselinesRequest(arg0 *ssm.DescribePatchBaselinesInput) (*request.Request, *ssm.DescribePatchBaselinesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchBaselinesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribePatchBaselinesOutput) - return ret0, ret1 -} - -// DescribePatchBaselinesRequest indicates an expected call of DescribePatchBaselinesRequest. -func (mr *MockSSMAPIMockRecorder) DescribePatchBaselinesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchBaselinesRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchBaselinesRequest), arg0) -} - -// DescribePatchBaselinesWithContext mocks base method. -func (m *MockSSMAPI) DescribePatchBaselinesWithContext(arg0 context.Context, arg1 *ssm.DescribePatchBaselinesInput, arg2 ...request.Option) (*ssm.DescribePatchBaselinesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePatchBaselinesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribePatchBaselinesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePatchBaselinesWithContext indicates an expected call of DescribePatchBaselinesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribePatchBaselinesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchBaselinesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchBaselinesWithContext), varargs...) -} - -// DescribePatchGroupState mocks base method. -func (m *MockSSMAPI) DescribePatchGroupState(arg0 *ssm.DescribePatchGroupStateInput) (*ssm.DescribePatchGroupStateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchGroupState", arg0) - ret0, _ := ret[0].(*ssm.DescribePatchGroupStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePatchGroupState indicates an expected call of DescribePatchGroupState. -func (mr *MockSSMAPIMockRecorder) DescribePatchGroupState(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchGroupState", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchGroupState), arg0) -} - -// DescribePatchGroupStateRequest mocks base method. -func (m *MockSSMAPI) DescribePatchGroupStateRequest(arg0 *ssm.DescribePatchGroupStateInput) (*request.Request, *ssm.DescribePatchGroupStateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchGroupStateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribePatchGroupStateOutput) - return ret0, ret1 -} - -// DescribePatchGroupStateRequest indicates an expected call of DescribePatchGroupStateRequest. -func (mr *MockSSMAPIMockRecorder) DescribePatchGroupStateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchGroupStateRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchGroupStateRequest), arg0) -} - -// DescribePatchGroupStateWithContext mocks base method. -func (m *MockSSMAPI) DescribePatchGroupStateWithContext(arg0 context.Context, arg1 *ssm.DescribePatchGroupStateInput, arg2 ...request.Option) (*ssm.DescribePatchGroupStateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePatchGroupStateWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribePatchGroupStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePatchGroupStateWithContext indicates an expected call of DescribePatchGroupStateWithContext. -func (mr *MockSSMAPIMockRecorder) DescribePatchGroupStateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchGroupStateWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchGroupStateWithContext), varargs...) -} - -// DescribePatchGroups mocks base method. -func (m *MockSSMAPI) DescribePatchGroups(arg0 *ssm.DescribePatchGroupsInput) (*ssm.DescribePatchGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchGroups", arg0) - ret0, _ := ret[0].(*ssm.DescribePatchGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePatchGroups indicates an expected call of DescribePatchGroups. -func (mr *MockSSMAPIMockRecorder) DescribePatchGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchGroups", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchGroups), arg0) -} - -// DescribePatchGroupsPages mocks base method. -func (m *MockSSMAPI) DescribePatchGroupsPages(arg0 *ssm.DescribePatchGroupsInput, arg1 func(*ssm.DescribePatchGroupsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchGroupsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePatchGroupsPages indicates an expected call of DescribePatchGroupsPages. -func (mr *MockSSMAPIMockRecorder) DescribePatchGroupsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchGroupsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchGroupsPages), arg0, arg1) -} - -// DescribePatchGroupsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribePatchGroupsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribePatchGroupsInput, arg2 func(*ssm.DescribePatchGroupsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePatchGroupsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePatchGroupsPagesWithContext indicates an expected call of DescribePatchGroupsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribePatchGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchGroupsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchGroupsPagesWithContext), varargs...) -} - -// DescribePatchGroupsRequest mocks base method. -func (m *MockSSMAPI) DescribePatchGroupsRequest(arg0 *ssm.DescribePatchGroupsInput) (*request.Request, *ssm.DescribePatchGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribePatchGroupsOutput) - return ret0, ret1 -} - -// DescribePatchGroupsRequest indicates an expected call of DescribePatchGroupsRequest. -func (mr *MockSSMAPIMockRecorder) DescribePatchGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchGroupsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchGroupsRequest), arg0) -} - -// DescribePatchGroupsWithContext mocks base method. -func (m *MockSSMAPI) DescribePatchGroupsWithContext(arg0 context.Context, arg1 *ssm.DescribePatchGroupsInput, arg2 ...request.Option) (*ssm.DescribePatchGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePatchGroupsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribePatchGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePatchGroupsWithContext indicates an expected call of DescribePatchGroupsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribePatchGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchGroupsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchGroupsWithContext), varargs...) -} - -// DescribePatchProperties mocks base method. -func (m *MockSSMAPI) DescribePatchProperties(arg0 *ssm.DescribePatchPropertiesInput) (*ssm.DescribePatchPropertiesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchProperties", arg0) - ret0, _ := ret[0].(*ssm.DescribePatchPropertiesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePatchProperties indicates an expected call of DescribePatchProperties. -func (mr *MockSSMAPIMockRecorder) DescribePatchProperties(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchProperties", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchProperties), arg0) -} - -// DescribePatchPropertiesPages mocks base method. -func (m *MockSSMAPI) DescribePatchPropertiesPages(arg0 *ssm.DescribePatchPropertiesInput, arg1 func(*ssm.DescribePatchPropertiesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchPropertiesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePatchPropertiesPages indicates an expected call of DescribePatchPropertiesPages. -func (mr *MockSSMAPIMockRecorder) DescribePatchPropertiesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchPropertiesPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchPropertiesPages), arg0, arg1) -} - -// DescribePatchPropertiesPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribePatchPropertiesPagesWithContext(arg0 context.Context, arg1 *ssm.DescribePatchPropertiesInput, arg2 func(*ssm.DescribePatchPropertiesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePatchPropertiesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePatchPropertiesPagesWithContext indicates an expected call of DescribePatchPropertiesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribePatchPropertiesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchPropertiesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchPropertiesPagesWithContext), varargs...) -} - -// DescribePatchPropertiesRequest mocks base method. -func (m *MockSSMAPI) DescribePatchPropertiesRequest(arg0 *ssm.DescribePatchPropertiesInput) (*request.Request, *ssm.DescribePatchPropertiesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePatchPropertiesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribePatchPropertiesOutput) - return ret0, ret1 -} - -// DescribePatchPropertiesRequest indicates an expected call of DescribePatchPropertiesRequest. -func (mr *MockSSMAPIMockRecorder) DescribePatchPropertiesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchPropertiesRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchPropertiesRequest), arg0) -} - -// DescribePatchPropertiesWithContext mocks base method. -func (m *MockSSMAPI) DescribePatchPropertiesWithContext(arg0 context.Context, arg1 *ssm.DescribePatchPropertiesInput, arg2 ...request.Option) (*ssm.DescribePatchPropertiesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePatchPropertiesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribePatchPropertiesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePatchPropertiesWithContext indicates an expected call of DescribePatchPropertiesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribePatchPropertiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePatchPropertiesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribePatchPropertiesWithContext), varargs...) -} - -// DescribeSessions mocks base method. -func (m *MockSSMAPI) DescribeSessions(arg0 *ssm.DescribeSessionsInput) (*ssm.DescribeSessionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSessions", arg0) - ret0, _ := ret[0].(*ssm.DescribeSessionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSessions indicates an expected call of DescribeSessions. -func (mr *MockSSMAPIMockRecorder) DescribeSessions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSessions", reflect.TypeOf((*MockSSMAPI)(nil).DescribeSessions), arg0) -} - -// DescribeSessionsPages mocks base method. -func (m *MockSSMAPI) DescribeSessionsPages(arg0 *ssm.DescribeSessionsInput, arg1 func(*ssm.DescribeSessionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSessionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSessionsPages indicates an expected call of DescribeSessionsPages. -func (mr *MockSSMAPIMockRecorder) DescribeSessionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSessionsPages", reflect.TypeOf((*MockSSMAPI)(nil).DescribeSessionsPages), arg0, arg1) -} - -// DescribeSessionsPagesWithContext mocks base method. -func (m *MockSSMAPI) DescribeSessionsPagesWithContext(arg0 context.Context, arg1 *ssm.DescribeSessionsInput, arg2 func(*ssm.DescribeSessionsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSessionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSessionsPagesWithContext indicates an expected call of DescribeSessionsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeSessionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSessionsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeSessionsPagesWithContext), varargs...) -} - -// DescribeSessionsRequest mocks base method. -func (m *MockSSMAPI) DescribeSessionsRequest(arg0 *ssm.DescribeSessionsInput) (*request.Request, *ssm.DescribeSessionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSessionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DescribeSessionsOutput) - return ret0, ret1 -} - -// DescribeSessionsRequest indicates an expected call of DescribeSessionsRequest. -func (mr *MockSSMAPIMockRecorder) DescribeSessionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSessionsRequest", reflect.TypeOf((*MockSSMAPI)(nil).DescribeSessionsRequest), arg0) -} - -// DescribeSessionsWithContext mocks base method. -func (m *MockSSMAPI) DescribeSessionsWithContext(arg0 context.Context, arg1 *ssm.DescribeSessionsInput, arg2 ...request.Option) (*ssm.DescribeSessionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSessionsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DescribeSessionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSessionsWithContext indicates an expected call of DescribeSessionsWithContext. -func (mr *MockSSMAPIMockRecorder) DescribeSessionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSessionsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DescribeSessionsWithContext), varargs...) -} - -// DisassociateOpsItemRelatedItem mocks base method. -func (m *MockSSMAPI) DisassociateOpsItemRelatedItem(arg0 *ssm.DisassociateOpsItemRelatedItemInput) (*ssm.DisassociateOpsItemRelatedItemOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateOpsItemRelatedItem", arg0) - ret0, _ := ret[0].(*ssm.DisassociateOpsItemRelatedItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateOpsItemRelatedItem indicates an expected call of DisassociateOpsItemRelatedItem. -func (mr *MockSSMAPIMockRecorder) DisassociateOpsItemRelatedItem(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateOpsItemRelatedItem", reflect.TypeOf((*MockSSMAPI)(nil).DisassociateOpsItemRelatedItem), arg0) -} - -// DisassociateOpsItemRelatedItemRequest mocks base method. -func (m *MockSSMAPI) DisassociateOpsItemRelatedItemRequest(arg0 *ssm.DisassociateOpsItemRelatedItemInput) (*request.Request, *ssm.DisassociateOpsItemRelatedItemOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateOpsItemRelatedItemRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.DisassociateOpsItemRelatedItemOutput) - return ret0, ret1 -} - -// DisassociateOpsItemRelatedItemRequest indicates an expected call of DisassociateOpsItemRelatedItemRequest. -func (mr *MockSSMAPIMockRecorder) DisassociateOpsItemRelatedItemRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateOpsItemRelatedItemRequest", reflect.TypeOf((*MockSSMAPI)(nil).DisassociateOpsItemRelatedItemRequest), arg0) -} - -// DisassociateOpsItemRelatedItemWithContext mocks base method. -func (m *MockSSMAPI) DisassociateOpsItemRelatedItemWithContext(arg0 context.Context, arg1 *ssm.DisassociateOpsItemRelatedItemInput, arg2 ...request.Option) (*ssm.DisassociateOpsItemRelatedItemOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateOpsItemRelatedItemWithContext", varargs...) - ret0, _ := ret[0].(*ssm.DisassociateOpsItemRelatedItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateOpsItemRelatedItemWithContext indicates an expected call of DisassociateOpsItemRelatedItemWithContext. -func (mr *MockSSMAPIMockRecorder) DisassociateOpsItemRelatedItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateOpsItemRelatedItemWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DisassociateOpsItemRelatedItemWithContext), varargs...) -} - -// GetAutomationExecution mocks base method. -func (m *MockSSMAPI) GetAutomationExecution(arg0 *ssm.GetAutomationExecutionInput) (*ssm.GetAutomationExecutionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAutomationExecution", arg0) - ret0, _ := ret[0].(*ssm.GetAutomationExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAutomationExecution indicates an expected call of GetAutomationExecution. -func (mr *MockSSMAPIMockRecorder) GetAutomationExecution(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAutomationExecution", reflect.TypeOf((*MockSSMAPI)(nil).GetAutomationExecution), arg0) -} - -// GetAutomationExecutionRequest mocks base method. -func (m *MockSSMAPI) GetAutomationExecutionRequest(arg0 *ssm.GetAutomationExecutionInput) (*request.Request, *ssm.GetAutomationExecutionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAutomationExecutionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetAutomationExecutionOutput) - return ret0, ret1 -} - -// GetAutomationExecutionRequest indicates an expected call of GetAutomationExecutionRequest. -func (mr *MockSSMAPIMockRecorder) GetAutomationExecutionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAutomationExecutionRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetAutomationExecutionRequest), arg0) -} - -// GetAutomationExecutionWithContext mocks base method. -func (m *MockSSMAPI) GetAutomationExecutionWithContext(arg0 context.Context, arg1 *ssm.GetAutomationExecutionInput, arg2 ...request.Option) (*ssm.GetAutomationExecutionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetAutomationExecutionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetAutomationExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAutomationExecutionWithContext indicates an expected call of GetAutomationExecutionWithContext. -func (mr *MockSSMAPIMockRecorder) GetAutomationExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAutomationExecutionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetAutomationExecutionWithContext), varargs...) -} - -// GetCalendarState mocks base method. -func (m *MockSSMAPI) GetCalendarState(arg0 *ssm.GetCalendarStateInput) (*ssm.GetCalendarStateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCalendarState", arg0) - ret0, _ := ret[0].(*ssm.GetCalendarStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCalendarState indicates an expected call of GetCalendarState. -func (mr *MockSSMAPIMockRecorder) GetCalendarState(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCalendarState", reflect.TypeOf((*MockSSMAPI)(nil).GetCalendarState), arg0) -} - -// GetCalendarStateRequest mocks base method. -func (m *MockSSMAPI) GetCalendarStateRequest(arg0 *ssm.GetCalendarStateInput) (*request.Request, *ssm.GetCalendarStateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCalendarStateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetCalendarStateOutput) - return ret0, ret1 -} - -// GetCalendarStateRequest indicates an expected call of GetCalendarStateRequest. -func (mr *MockSSMAPIMockRecorder) GetCalendarStateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCalendarStateRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetCalendarStateRequest), arg0) -} - -// GetCalendarStateWithContext mocks base method. -func (m *MockSSMAPI) GetCalendarStateWithContext(arg0 context.Context, arg1 *ssm.GetCalendarStateInput, arg2 ...request.Option) (*ssm.GetCalendarStateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetCalendarStateWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetCalendarStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCalendarStateWithContext indicates an expected call of GetCalendarStateWithContext. -func (mr *MockSSMAPIMockRecorder) GetCalendarStateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCalendarStateWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetCalendarStateWithContext), varargs...) -} - -// GetCommandInvocation mocks base method. -func (m *MockSSMAPI) GetCommandInvocation(arg0 *ssm.GetCommandInvocationInput) (*ssm.GetCommandInvocationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCommandInvocation", arg0) - ret0, _ := ret[0].(*ssm.GetCommandInvocationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCommandInvocation indicates an expected call of GetCommandInvocation. -func (mr *MockSSMAPIMockRecorder) GetCommandInvocation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommandInvocation", reflect.TypeOf((*MockSSMAPI)(nil).GetCommandInvocation), arg0) -} - -// GetCommandInvocationRequest mocks base method. -func (m *MockSSMAPI) GetCommandInvocationRequest(arg0 *ssm.GetCommandInvocationInput) (*request.Request, *ssm.GetCommandInvocationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCommandInvocationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetCommandInvocationOutput) - return ret0, ret1 -} - -// GetCommandInvocationRequest indicates an expected call of GetCommandInvocationRequest. -func (mr *MockSSMAPIMockRecorder) GetCommandInvocationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommandInvocationRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetCommandInvocationRequest), arg0) -} - -// GetCommandInvocationWithContext mocks base method. -func (m *MockSSMAPI) GetCommandInvocationWithContext(arg0 context.Context, arg1 *ssm.GetCommandInvocationInput, arg2 ...request.Option) (*ssm.GetCommandInvocationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetCommandInvocationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetCommandInvocationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCommandInvocationWithContext indicates an expected call of GetCommandInvocationWithContext. -func (mr *MockSSMAPIMockRecorder) GetCommandInvocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommandInvocationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetCommandInvocationWithContext), varargs...) -} - -// GetConnectionStatus mocks base method. -func (m *MockSSMAPI) GetConnectionStatus(arg0 *ssm.GetConnectionStatusInput) (*ssm.GetConnectionStatusOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetConnectionStatus", arg0) - ret0, _ := ret[0].(*ssm.GetConnectionStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetConnectionStatus indicates an expected call of GetConnectionStatus. -func (mr *MockSSMAPIMockRecorder) GetConnectionStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionStatus", reflect.TypeOf((*MockSSMAPI)(nil).GetConnectionStatus), arg0) -} - -// GetConnectionStatusRequest mocks base method. -func (m *MockSSMAPI) GetConnectionStatusRequest(arg0 *ssm.GetConnectionStatusInput) (*request.Request, *ssm.GetConnectionStatusOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetConnectionStatusRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetConnectionStatusOutput) - return ret0, ret1 -} - -// GetConnectionStatusRequest indicates an expected call of GetConnectionStatusRequest. -func (mr *MockSSMAPIMockRecorder) GetConnectionStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionStatusRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetConnectionStatusRequest), arg0) -} - -// GetConnectionStatusWithContext mocks base method. -func (m *MockSSMAPI) GetConnectionStatusWithContext(arg0 context.Context, arg1 *ssm.GetConnectionStatusInput, arg2 ...request.Option) (*ssm.GetConnectionStatusOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetConnectionStatusWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetConnectionStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetConnectionStatusWithContext indicates an expected call of GetConnectionStatusWithContext. -func (mr *MockSSMAPIMockRecorder) GetConnectionStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionStatusWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetConnectionStatusWithContext), varargs...) -} - -// GetDefaultPatchBaseline mocks base method. -func (m *MockSSMAPI) GetDefaultPatchBaseline(arg0 *ssm.GetDefaultPatchBaselineInput) (*ssm.GetDefaultPatchBaselineOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDefaultPatchBaseline", arg0) - ret0, _ := ret[0].(*ssm.GetDefaultPatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetDefaultPatchBaseline indicates an expected call of GetDefaultPatchBaseline. -func (mr *MockSSMAPIMockRecorder) GetDefaultPatchBaseline(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultPatchBaseline", reflect.TypeOf((*MockSSMAPI)(nil).GetDefaultPatchBaseline), arg0) -} - -// GetDefaultPatchBaselineRequest mocks base method. -func (m *MockSSMAPI) GetDefaultPatchBaselineRequest(arg0 *ssm.GetDefaultPatchBaselineInput) (*request.Request, *ssm.GetDefaultPatchBaselineOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDefaultPatchBaselineRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetDefaultPatchBaselineOutput) - return ret0, ret1 -} - -// GetDefaultPatchBaselineRequest indicates an expected call of GetDefaultPatchBaselineRequest. -func (mr *MockSSMAPIMockRecorder) GetDefaultPatchBaselineRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultPatchBaselineRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetDefaultPatchBaselineRequest), arg0) -} - -// GetDefaultPatchBaselineWithContext mocks base method. -func (m *MockSSMAPI) GetDefaultPatchBaselineWithContext(arg0 context.Context, arg1 *ssm.GetDefaultPatchBaselineInput, arg2 ...request.Option) (*ssm.GetDefaultPatchBaselineOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetDefaultPatchBaselineWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetDefaultPatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetDefaultPatchBaselineWithContext indicates an expected call of GetDefaultPatchBaselineWithContext. -func (mr *MockSSMAPIMockRecorder) GetDefaultPatchBaselineWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultPatchBaselineWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetDefaultPatchBaselineWithContext), varargs...) -} - -// GetDeployablePatchSnapshotForInstance mocks base method. -func (m *MockSSMAPI) GetDeployablePatchSnapshotForInstance(arg0 *ssm.GetDeployablePatchSnapshotForInstanceInput) (*ssm.GetDeployablePatchSnapshotForInstanceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDeployablePatchSnapshotForInstance", arg0) - ret0, _ := ret[0].(*ssm.GetDeployablePatchSnapshotForInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetDeployablePatchSnapshotForInstance indicates an expected call of GetDeployablePatchSnapshotForInstance. -func (mr *MockSSMAPIMockRecorder) GetDeployablePatchSnapshotForInstance(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployablePatchSnapshotForInstance", reflect.TypeOf((*MockSSMAPI)(nil).GetDeployablePatchSnapshotForInstance), arg0) -} - -// GetDeployablePatchSnapshotForInstanceRequest mocks base method. -func (m *MockSSMAPI) GetDeployablePatchSnapshotForInstanceRequest(arg0 *ssm.GetDeployablePatchSnapshotForInstanceInput) (*request.Request, *ssm.GetDeployablePatchSnapshotForInstanceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDeployablePatchSnapshotForInstanceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetDeployablePatchSnapshotForInstanceOutput) - return ret0, ret1 -} - -// GetDeployablePatchSnapshotForInstanceRequest indicates an expected call of GetDeployablePatchSnapshotForInstanceRequest. -func (mr *MockSSMAPIMockRecorder) GetDeployablePatchSnapshotForInstanceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployablePatchSnapshotForInstanceRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetDeployablePatchSnapshotForInstanceRequest), arg0) -} - -// GetDeployablePatchSnapshotForInstanceWithContext mocks base method. -func (m *MockSSMAPI) GetDeployablePatchSnapshotForInstanceWithContext(arg0 context.Context, arg1 *ssm.GetDeployablePatchSnapshotForInstanceInput, arg2 ...request.Option) (*ssm.GetDeployablePatchSnapshotForInstanceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetDeployablePatchSnapshotForInstanceWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetDeployablePatchSnapshotForInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetDeployablePatchSnapshotForInstanceWithContext indicates an expected call of GetDeployablePatchSnapshotForInstanceWithContext. -func (mr *MockSSMAPIMockRecorder) GetDeployablePatchSnapshotForInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployablePatchSnapshotForInstanceWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetDeployablePatchSnapshotForInstanceWithContext), varargs...) -} - -// GetDocument mocks base method. -func (m *MockSSMAPI) GetDocument(arg0 *ssm.GetDocumentInput) (*ssm.GetDocumentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDocument", arg0) - ret0, _ := ret[0].(*ssm.GetDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetDocument indicates an expected call of GetDocument. -func (mr *MockSSMAPIMockRecorder) GetDocument(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocument", reflect.TypeOf((*MockSSMAPI)(nil).GetDocument), arg0) -} - -// GetDocumentRequest mocks base method. -func (m *MockSSMAPI) GetDocumentRequest(arg0 *ssm.GetDocumentInput) (*request.Request, *ssm.GetDocumentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDocumentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetDocumentOutput) - return ret0, ret1 -} - -// GetDocumentRequest indicates an expected call of GetDocumentRequest. -func (mr *MockSSMAPIMockRecorder) GetDocumentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocumentRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetDocumentRequest), arg0) -} - -// GetDocumentWithContext mocks base method. -func (m *MockSSMAPI) GetDocumentWithContext(arg0 context.Context, arg1 *ssm.GetDocumentInput, arg2 ...request.Option) (*ssm.GetDocumentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetDocumentWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetDocumentWithContext indicates an expected call of GetDocumentWithContext. -func (mr *MockSSMAPIMockRecorder) GetDocumentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocumentWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetDocumentWithContext), varargs...) -} - -// GetInventory mocks base method. -func (m *MockSSMAPI) GetInventory(arg0 *ssm.GetInventoryInput) (*ssm.GetInventoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInventory", arg0) - ret0, _ := ret[0].(*ssm.GetInventoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInventory indicates an expected call of GetInventory. -func (mr *MockSSMAPIMockRecorder) GetInventory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventory", reflect.TypeOf((*MockSSMAPI)(nil).GetInventory), arg0) -} - -// GetInventoryPages mocks base method. -func (m *MockSSMAPI) GetInventoryPages(arg0 *ssm.GetInventoryInput, arg1 func(*ssm.GetInventoryOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInventoryPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetInventoryPages indicates an expected call of GetInventoryPages. -func (mr *MockSSMAPIMockRecorder) GetInventoryPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventoryPages", reflect.TypeOf((*MockSSMAPI)(nil).GetInventoryPages), arg0, arg1) -} - -// GetInventoryPagesWithContext mocks base method. -func (m *MockSSMAPI) GetInventoryPagesWithContext(arg0 context.Context, arg1 *ssm.GetInventoryInput, arg2 func(*ssm.GetInventoryOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetInventoryPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetInventoryPagesWithContext indicates an expected call of GetInventoryPagesWithContext. -func (mr *MockSSMAPIMockRecorder) GetInventoryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventoryPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetInventoryPagesWithContext), varargs...) -} - -// GetInventoryRequest mocks base method. -func (m *MockSSMAPI) GetInventoryRequest(arg0 *ssm.GetInventoryInput) (*request.Request, *ssm.GetInventoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInventoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetInventoryOutput) - return ret0, ret1 -} - -// GetInventoryRequest indicates an expected call of GetInventoryRequest. -func (mr *MockSSMAPIMockRecorder) GetInventoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventoryRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetInventoryRequest), arg0) -} - -// GetInventorySchema mocks base method. -func (m *MockSSMAPI) GetInventorySchema(arg0 *ssm.GetInventorySchemaInput) (*ssm.GetInventorySchemaOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInventorySchema", arg0) - ret0, _ := ret[0].(*ssm.GetInventorySchemaOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInventorySchema indicates an expected call of GetInventorySchema. -func (mr *MockSSMAPIMockRecorder) GetInventorySchema(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventorySchema", reflect.TypeOf((*MockSSMAPI)(nil).GetInventorySchema), arg0) -} - -// GetInventorySchemaPages mocks base method. -func (m *MockSSMAPI) GetInventorySchemaPages(arg0 *ssm.GetInventorySchemaInput, arg1 func(*ssm.GetInventorySchemaOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInventorySchemaPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetInventorySchemaPages indicates an expected call of GetInventorySchemaPages. -func (mr *MockSSMAPIMockRecorder) GetInventorySchemaPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventorySchemaPages", reflect.TypeOf((*MockSSMAPI)(nil).GetInventorySchemaPages), arg0, arg1) -} - -// GetInventorySchemaPagesWithContext mocks base method. -func (m *MockSSMAPI) GetInventorySchemaPagesWithContext(arg0 context.Context, arg1 *ssm.GetInventorySchemaInput, arg2 func(*ssm.GetInventorySchemaOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetInventorySchemaPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetInventorySchemaPagesWithContext indicates an expected call of GetInventorySchemaPagesWithContext. -func (mr *MockSSMAPIMockRecorder) GetInventorySchemaPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventorySchemaPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetInventorySchemaPagesWithContext), varargs...) -} - -// GetInventorySchemaRequest mocks base method. -func (m *MockSSMAPI) GetInventorySchemaRequest(arg0 *ssm.GetInventorySchemaInput) (*request.Request, *ssm.GetInventorySchemaOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInventorySchemaRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetInventorySchemaOutput) - return ret0, ret1 -} - -// GetInventorySchemaRequest indicates an expected call of GetInventorySchemaRequest. -func (mr *MockSSMAPIMockRecorder) GetInventorySchemaRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventorySchemaRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetInventorySchemaRequest), arg0) -} - -// GetInventorySchemaWithContext mocks base method. -func (m *MockSSMAPI) GetInventorySchemaWithContext(arg0 context.Context, arg1 *ssm.GetInventorySchemaInput, arg2 ...request.Option) (*ssm.GetInventorySchemaOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetInventorySchemaWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetInventorySchemaOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInventorySchemaWithContext indicates an expected call of GetInventorySchemaWithContext. -func (mr *MockSSMAPIMockRecorder) GetInventorySchemaWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventorySchemaWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetInventorySchemaWithContext), varargs...) -} - -// GetInventoryWithContext mocks base method. -func (m *MockSSMAPI) GetInventoryWithContext(arg0 context.Context, arg1 *ssm.GetInventoryInput, arg2 ...request.Option) (*ssm.GetInventoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetInventoryWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetInventoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInventoryWithContext indicates an expected call of GetInventoryWithContext. -func (mr *MockSSMAPIMockRecorder) GetInventoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInventoryWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetInventoryWithContext), varargs...) -} - -// GetMaintenanceWindow mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindow(arg0 *ssm.GetMaintenanceWindowInput) (*ssm.GetMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindow", arg0) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindow indicates an expected call of GetMaintenanceWindow. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindow", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindow), arg0) -} - -// GetMaintenanceWindowExecution mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecution(arg0 *ssm.GetMaintenanceWindowExecutionInput) (*ssm.GetMaintenanceWindowExecutionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecution", arg0) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowExecution indicates an expected call of GetMaintenanceWindowExecution. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecution(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecution", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecution), arg0) -} - -// GetMaintenanceWindowExecutionRequest mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecutionRequest(arg0 *ssm.GetMaintenanceWindowExecutionInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecutionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetMaintenanceWindowExecutionOutput) - return ret0, ret1 -} - -// GetMaintenanceWindowExecutionRequest indicates an expected call of GetMaintenanceWindowExecutionRequest. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecutionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecutionRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecutionRequest), arg0) -} - -// GetMaintenanceWindowExecutionTask mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecutionTask(arg0 *ssm.GetMaintenanceWindowExecutionTaskInput) (*ssm.GetMaintenanceWindowExecutionTaskOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecutionTask", arg0) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowExecutionTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowExecutionTask indicates an expected call of GetMaintenanceWindowExecutionTask. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecutionTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecutionTask", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecutionTask), arg0) -} - -// GetMaintenanceWindowExecutionTaskInvocation mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecutionTaskInvocation(arg0 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput) (*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecutionTaskInvocation", arg0) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowExecutionTaskInvocation indicates an expected call of GetMaintenanceWindowExecutionTaskInvocation. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecutionTaskInvocation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecutionTaskInvocation", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecutionTaskInvocation), arg0) -} - -// GetMaintenanceWindowExecutionTaskInvocationRequest mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecutionTaskInvocationRequest(arg0 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecutionTaskInvocationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput) - return ret0, ret1 -} - -// GetMaintenanceWindowExecutionTaskInvocationRequest indicates an expected call of GetMaintenanceWindowExecutionTaskInvocationRequest. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecutionTaskInvocationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecutionTaskInvocationRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecutionTaskInvocationRequest), arg0) -} - -// GetMaintenanceWindowExecutionTaskInvocationWithContext mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecutionTaskInvocationWithContext(arg0 context.Context, arg1 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput, arg2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecutionTaskInvocationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowExecutionTaskInvocationWithContext indicates an expected call of GetMaintenanceWindowExecutionTaskInvocationWithContext. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecutionTaskInvocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecutionTaskInvocationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecutionTaskInvocationWithContext), varargs...) -} - -// GetMaintenanceWindowExecutionTaskRequest mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecutionTaskRequest(arg0 *ssm.GetMaintenanceWindowExecutionTaskInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionTaskOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecutionTaskRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetMaintenanceWindowExecutionTaskOutput) - return ret0, ret1 -} - -// GetMaintenanceWindowExecutionTaskRequest indicates an expected call of GetMaintenanceWindowExecutionTaskRequest. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecutionTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecutionTaskRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecutionTaskRequest), arg0) -} - -// GetMaintenanceWindowExecutionTaskWithContext mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecutionTaskWithContext(arg0 context.Context, arg1 *ssm.GetMaintenanceWindowExecutionTaskInput, arg2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionTaskOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecutionTaskWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowExecutionTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowExecutionTaskWithContext indicates an expected call of GetMaintenanceWindowExecutionTaskWithContext. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecutionTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecutionTaskWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecutionTaskWithContext), varargs...) -} - -// GetMaintenanceWindowExecutionWithContext mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowExecutionWithContext(arg0 context.Context, arg1 *ssm.GetMaintenanceWindowExecutionInput, arg2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetMaintenanceWindowExecutionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowExecutionWithContext indicates an expected call of GetMaintenanceWindowExecutionWithContext. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowExecutionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowExecutionWithContext), varargs...) -} - -// GetMaintenanceWindowRequest mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowRequest(arg0 *ssm.GetMaintenanceWindowInput) (*request.Request, *ssm.GetMaintenanceWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetMaintenanceWindowOutput) - return ret0, ret1 -} - -// GetMaintenanceWindowRequest indicates an expected call of GetMaintenanceWindowRequest. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowRequest), arg0) -} - -// GetMaintenanceWindowTask mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowTask(arg0 *ssm.GetMaintenanceWindowTaskInput) (*ssm.GetMaintenanceWindowTaskOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowTask", arg0) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowTask indicates an expected call of GetMaintenanceWindowTask. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowTask", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowTask), arg0) -} - -// GetMaintenanceWindowTaskRequest mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowTaskRequest(arg0 *ssm.GetMaintenanceWindowTaskInput) (*request.Request, *ssm.GetMaintenanceWindowTaskOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaintenanceWindowTaskRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetMaintenanceWindowTaskOutput) - return ret0, ret1 -} - -// GetMaintenanceWindowTaskRequest indicates an expected call of GetMaintenanceWindowTaskRequest. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowTaskRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowTaskRequest), arg0) -} - -// GetMaintenanceWindowTaskWithContext mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowTaskWithContext(arg0 context.Context, arg1 *ssm.GetMaintenanceWindowTaskInput, arg2 ...request.Option) (*ssm.GetMaintenanceWindowTaskOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetMaintenanceWindowTaskWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowTaskWithContext indicates an expected call of GetMaintenanceWindowTaskWithContext. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowTaskWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowTaskWithContext), varargs...) -} - -// GetMaintenanceWindowWithContext mocks base method. -func (m *MockSSMAPI) GetMaintenanceWindowWithContext(arg0 context.Context, arg1 *ssm.GetMaintenanceWindowInput, arg2 ...request.Option) (*ssm.GetMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetMaintenanceWindowWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMaintenanceWindowWithContext indicates an expected call of GetMaintenanceWindowWithContext. -func (mr *MockSSMAPIMockRecorder) GetMaintenanceWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetMaintenanceWindowWithContext), varargs...) -} - -// GetOpsItem mocks base method. -func (m *MockSSMAPI) GetOpsItem(arg0 *ssm.GetOpsItemInput) (*ssm.GetOpsItemOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOpsItem", arg0) - ret0, _ := ret[0].(*ssm.GetOpsItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetOpsItem indicates an expected call of GetOpsItem. -func (mr *MockSSMAPIMockRecorder) GetOpsItem(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsItem", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsItem), arg0) -} - -// GetOpsItemRequest mocks base method. -func (m *MockSSMAPI) GetOpsItemRequest(arg0 *ssm.GetOpsItemInput) (*request.Request, *ssm.GetOpsItemOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOpsItemRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetOpsItemOutput) - return ret0, ret1 -} - -// GetOpsItemRequest indicates an expected call of GetOpsItemRequest. -func (mr *MockSSMAPIMockRecorder) GetOpsItemRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsItemRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsItemRequest), arg0) -} - -// GetOpsItemWithContext mocks base method. -func (m *MockSSMAPI) GetOpsItemWithContext(arg0 context.Context, arg1 *ssm.GetOpsItemInput, arg2 ...request.Option) (*ssm.GetOpsItemOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetOpsItemWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetOpsItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetOpsItemWithContext indicates an expected call of GetOpsItemWithContext. -func (mr *MockSSMAPIMockRecorder) GetOpsItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsItemWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsItemWithContext), varargs...) -} - -// GetOpsMetadata mocks base method. -func (m *MockSSMAPI) GetOpsMetadata(arg0 *ssm.GetOpsMetadataInput) (*ssm.GetOpsMetadataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOpsMetadata", arg0) - ret0, _ := ret[0].(*ssm.GetOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetOpsMetadata indicates an expected call of GetOpsMetadata. -func (mr *MockSSMAPIMockRecorder) GetOpsMetadata(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsMetadata", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsMetadata), arg0) -} - -// GetOpsMetadataRequest mocks base method. -func (m *MockSSMAPI) GetOpsMetadataRequest(arg0 *ssm.GetOpsMetadataInput) (*request.Request, *ssm.GetOpsMetadataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOpsMetadataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetOpsMetadataOutput) - return ret0, ret1 -} - -// GetOpsMetadataRequest indicates an expected call of GetOpsMetadataRequest. -func (mr *MockSSMAPIMockRecorder) GetOpsMetadataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsMetadataRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsMetadataRequest), arg0) -} - -// GetOpsMetadataWithContext mocks base method. -func (m *MockSSMAPI) GetOpsMetadataWithContext(arg0 context.Context, arg1 *ssm.GetOpsMetadataInput, arg2 ...request.Option) (*ssm.GetOpsMetadataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetOpsMetadataWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetOpsMetadataWithContext indicates an expected call of GetOpsMetadataWithContext. -func (mr *MockSSMAPIMockRecorder) GetOpsMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsMetadataWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsMetadataWithContext), varargs...) -} - -// GetOpsSummary mocks base method. -func (m *MockSSMAPI) GetOpsSummary(arg0 *ssm.GetOpsSummaryInput) (*ssm.GetOpsSummaryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOpsSummary", arg0) - ret0, _ := ret[0].(*ssm.GetOpsSummaryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetOpsSummary indicates an expected call of GetOpsSummary. -func (mr *MockSSMAPIMockRecorder) GetOpsSummary(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsSummary", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsSummary), arg0) -} - -// GetOpsSummaryPages mocks base method. -func (m *MockSSMAPI) GetOpsSummaryPages(arg0 *ssm.GetOpsSummaryInput, arg1 func(*ssm.GetOpsSummaryOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOpsSummaryPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetOpsSummaryPages indicates an expected call of GetOpsSummaryPages. -func (mr *MockSSMAPIMockRecorder) GetOpsSummaryPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsSummaryPages", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsSummaryPages), arg0, arg1) -} - -// GetOpsSummaryPagesWithContext mocks base method. -func (m *MockSSMAPI) GetOpsSummaryPagesWithContext(arg0 context.Context, arg1 *ssm.GetOpsSummaryInput, arg2 func(*ssm.GetOpsSummaryOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetOpsSummaryPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetOpsSummaryPagesWithContext indicates an expected call of GetOpsSummaryPagesWithContext. -func (mr *MockSSMAPIMockRecorder) GetOpsSummaryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsSummaryPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsSummaryPagesWithContext), varargs...) -} - -// GetOpsSummaryRequest mocks base method. -func (m *MockSSMAPI) GetOpsSummaryRequest(arg0 *ssm.GetOpsSummaryInput) (*request.Request, *ssm.GetOpsSummaryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOpsSummaryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetOpsSummaryOutput) - return ret0, ret1 -} - -// GetOpsSummaryRequest indicates an expected call of GetOpsSummaryRequest. -func (mr *MockSSMAPIMockRecorder) GetOpsSummaryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsSummaryRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsSummaryRequest), arg0) -} - -// GetOpsSummaryWithContext mocks base method. -func (m *MockSSMAPI) GetOpsSummaryWithContext(arg0 context.Context, arg1 *ssm.GetOpsSummaryInput, arg2 ...request.Option) (*ssm.GetOpsSummaryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetOpsSummaryWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetOpsSummaryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetOpsSummaryWithContext indicates an expected call of GetOpsSummaryWithContext. -func (mr *MockSSMAPIMockRecorder) GetOpsSummaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpsSummaryWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetOpsSummaryWithContext), varargs...) -} - -// GetParameter mocks base method. -func (m *MockSSMAPI) GetParameter(arg0 *ssm.GetParameterInput) (*ssm.GetParameterOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParameter", arg0) - ret0, _ := ret[0].(*ssm.GetParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParameter indicates an expected call of GetParameter. -func (mr *MockSSMAPIMockRecorder) GetParameter(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameter", reflect.TypeOf((*MockSSMAPI)(nil).GetParameter), arg0) -} - -// GetParameterHistory mocks base method. -func (m *MockSSMAPI) GetParameterHistory(arg0 *ssm.GetParameterHistoryInput) (*ssm.GetParameterHistoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParameterHistory", arg0) - ret0, _ := ret[0].(*ssm.GetParameterHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParameterHistory indicates an expected call of GetParameterHistory. -func (mr *MockSSMAPIMockRecorder) GetParameterHistory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameterHistory", reflect.TypeOf((*MockSSMAPI)(nil).GetParameterHistory), arg0) -} - -// GetParameterHistoryPages mocks base method. -func (m *MockSSMAPI) GetParameterHistoryPages(arg0 *ssm.GetParameterHistoryInput, arg1 func(*ssm.GetParameterHistoryOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParameterHistoryPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetParameterHistoryPages indicates an expected call of GetParameterHistoryPages. -func (mr *MockSSMAPIMockRecorder) GetParameterHistoryPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameterHistoryPages", reflect.TypeOf((*MockSSMAPI)(nil).GetParameterHistoryPages), arg0, arg1) -} - -// GetParameterHistoryPagesWithContext mocks base method. -func (m *MockSSMAPI) GetParameterHistoryPagesWithContext(arg0 context.Context, arg1 *ssm.GetParameterHistoryInput, arg2 func(*ssm.GetParameterHistoryOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetParameterHistoryPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetParameterHistoryPagesWithContext indicates an expected call of GetParameterHistoryPagesWithContext. -func (mr *MockSSMAPIMockRecorder) GetParameterHistoryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameterHistoryPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetParameterHistoryPagesWithContext), varargs...) -} - -// GetParameterHistoryRequest mocks base method. -func (m *MockSSMAPI) GetParameterHistoryRequest(arg0 *ssm.GetParameterHistoryInput) (*request.Request, *ssm.GetParameterHistoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParameterHistoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetParameterHistoryOutput) - return ret0, ret1 -} - -// GetParameterHistoryRequest indicates an expected call of GetParameterHistoryRequest. -func (mr *MockSSMAPIMockRecorder) GetParameterHistoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameterHistoryRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetParameterHistoryRequest), arg0) -} - -// GetParameterHistoryWithContext mocks base method. -func (m *MockSSMAPI) GetParameterHistoryWithContext(arg0 context.Context, arg1 *ssm.GetParameterHistoryInput, arg2 ...request.Option) (*ssm.GetParameterHistoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetParameterHistoryWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetParameterHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParameterHistoryWithContext indicates an expected call of GetParameterHistoryWithContext. -func (mr *MockSSMAPIMockRecorder) GetParameterHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameterHistoryWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetParameterHistoryWithContext), varargs...) -} - -// GetParameterRequest mocks base method. -func (m *MockSSMAPI) GetParameterRequest(arg0 *ssm.GetParameterInput) (*request.Request, *ssm.GetParameterOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParameterRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetParameterOutput) - return ret0, ret1 -} - -// GetParameterRequest indicates an expected call of GetParameterRequest. -func (mr *MockSSMAPIMockRecorder) GetParameterRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameterRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetParameterRequest), arg0) -} - -// GetParameterWithContext mocks base method. -func (m *MockSSMAPI) GetParameterWithContext(arg0 context.Context, arg1 *ssm.GetParameterInput, arg2 ...request.Option) (*ssm.GetParameterOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetParameterWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParameterWithContext indicates an expected call of GetParameterWithContext. -func (mr *MockSSMAPIMockRecorder) GetParameterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameterWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetParameterWithContext), varargs...) -} - -// GetParameters mocks base method. -func (m *MockSSMAPI) GetParameters(arg0 *ssm.GetParametersInput) (*ssm.GetParametersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParameters", arg0) - ret0, _ := ret[0].(*ssm.GetParametersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParameters indicates an expected call of GetParameters. -func (mr *MockSSMAPIMockRecorder) GetParameters(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameters", reflect.TypeOf((*MockSSMAPI)(nil).GetParameters), arg0) -} - -// GetParametersByPath mocks base method. -func (m *MockSSMAPI) GetParametersByPath(arg0 *ssm.GetParametersByPathInput) (*ssm.GetParametersByPathOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParametersByPath", arg0) - ret0, _ := ret[0].(*ssm.GetParametersByPathOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParametersByPath indicates an expected call of GetParametersByPath. -func (mr *MockSSMAPIMockRecorder) GetParametersByPath(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersByPath", reflect.TypeOf((*MockSSMAPI)(nil).GetParametersByPath), arg0) -} - -// GetParametersByPathPages mocks base method. -func (m *MockSSMAPI) GetParametersByPathPages(arg0 *ssm.GetParametersByPathInput, arg1 func(*ssm.GetParametersByPathOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParametersByPathPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetParametersByPathPages indicates an expected call of GetParametersByPathPages. -func (mr *MockSSMAPIMockRecorder) GetParametersByPathPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersByPathPages", reflect.TypeOf((*MockSSMAPI)(nil).GetParametersByPathPages), arg0, arg1) -} - -// GetParametersByPathPagesWithContext mocks base method. -func (m *MockSSMAPI) GetParametersByPathPagesWithContext(arg0 context.Context, arg1 *ssm.GetParametersByPathInput, arg2 func(*ssm.GetParametersByPathOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetParametersByPathPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetParametersByPathPagesWithContext indicates an expected call of GetParametersByPathPagesWithContext. -func (mr *MockSSMAPIMockRecorder) GetParametersByPathPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersByPathPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetParametersByPathPagesWithContext), varargs...) -} - -// GetParametersByPathRequest mocks base method. -func (m *MockSSMAPI) GetParametersByPathRequest(arg0 *ssm.GetParametersByPathInput) (*request.Request, *ssm.GetParametersByPathOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParametersByPathRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetParametersByPathOutput) - return ret0, ret1 -} - -// GetParametersByPathRequest indicates an expected call of GetParametersByPathRequest. -func (mr *MockSSMAPIMockRecorder) GetParametersByPathRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersByPathRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetParametersByPathRequest), arg0) -} - -// GetParametersByPathWithContext mocks base method. -func (m *MockSSMAPI) GetParametersByPathWithContext(arg0 context.Context, arg1 *ssm.GetParametersByPathInput, arg2 ...request.Option) (*ssm.GetParametersByPathOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetParametersByPathWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetParametersByPathOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParametersByPathWithContext indicates an expected call of GetParametersByPathWithContext. -func (mr *MockSSMAPIMockRecorder) GetParametersByPathWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersByPathWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetParametersByPathWithContext), varargs...) -} - -// GetParametersRequest mocks base method. -func (m *MockSSMAPI) GetParametersRequest(arg0 *ssm.GetParametersInput) (*request.Request, *ssm.GetParametersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParametersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetParametersOutput) - return ret0, ret1 -} - -// GetParametersRequest indicates an expected call of GetParametersRequest. -func (mr *MockSSMAPIMockRecorder) GetParametersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetParametersRequest), arg0) -} - -// GetParametersWithContext mocks base method. -func (m *MockSSMAPI) GetParametersWithContext(arg0 context.Context, arg1 *ssm.GetParametersInput, arg2 ...request.Option) (*ssm.GetParametersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetParametersWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetParametersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParametersWithContext indicates an expected call of GetParametersWithContext. -func (mr *MockSSMAPIMockRecorder) GetParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetParametersWithContext), varargs...) -} - -// GetPatchBaseline mocks base method. -func (m *MockSSMAPI) GetPatchBaseline(arg0 *ssm.GetPatchBaselineInput) (*ssm.GetPatchBaselineOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPatchBaseline", arg0) - ret0, _ := ret[0].(*ssm.GetPatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetPatchBaseline indicates an expected call of GetPatchBaseline. -func (mr *MockSSMAPIMockRecorder) GetPatchBaseline(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatchBaseline", reflect.TypeOf((*MockSSMAPI)(nil).GetPatchBaseline), arg0) -} - -// GetPatchBaselineForPatchGroup mocks base method. -func (m *MockSSMAPI) GetPatchBaselineForPatchGroup(arg0 *ssm.GetPatchBaselineForPatchGroupInput) (*ssm.GetPatchBaselineForPatchGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPatchBaselineForPatchGroup", arg0) - ret0, _ := ret[0].(*ssm.GetPatchBaselineForPatchGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetPatchBaselineForPatchGroup indicates an expected call of GetPatchBaselineForPatchGroup. -func (mr *MockSSMAPIMockRecorder) GetPatchBaselineForPatchGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatchBaselineForPatchGroup", reflect.TypeOf((*MockSSMAPI)(nil).GetPatchBaselineForPatchGroup), arg0) -} - -// GetPatchBaselineForPatchGroupRequest mocks base method. -func (m *MockSSMAPI) GetPatchBaselineForPatchGroupRequest(arg0 *ssm.GetPatchBaselineForPatchGroupInput) (*request.Request, *ssm.GetPatchBaselineForPatchGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPatchBaselineForPatchGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetPatchBaselineForPatchGroupOutput) - return ret0, ret1 -} - -// GetPatchBaselineForPatchGroupRequest indicates an expected call of GetPatchBaselineForPatchGroupRequest. -func (mr *MockSSMAPIMockRecorder) GetPatchBaselineForPatchGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatchBaselineForPatchGroupRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetPatchBaselineForPatchGroupRequest), arg0) -} - -// GetPatchBaselineForPatchGroupWithContext mocks base method. -func (m *MockSSMAPI) GetPatchBaselineForPatchGroupWithContext(arg0 context.Context, arg1 *ssm.GetPatchBaselineForPatchGroupInput, arg2 ...request.Option) (*ssm.GetPatchBaselineForPatchGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetPatchBaselineForPatchGroupWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetPatchBaselineForPatchGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetPatchBaselineForPatchGroupWithContext indicates an expected call of GetPatchBaselineForPatchGroupWithContext. -func (mr *MockSSMAPIMockRecorder) GetPatchBaselineForPatchGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatchBaselineForPatchGroupWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetPatchBaselineForPatchGroupWithContext), varargs...) -} - -// GetPatchBaselineRequest mocks base method. -func (m *MockSSMAPI) GetPatchBaselineRequest(arg0 *ssm.GetPatchBaselineInput) (*request.Request, *ssm.GetPatchBaselineOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPatchBaselineRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetPatchBaselineOutput) - return ret0, ret1 -} - -// GetPatchBaselineRequest indicates an expected call of GetPatchBaselineRequest. -func (mr *MockSSMAPIMockRecorder) GetPatchBaselineRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatchBaselineRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetPatchBaselineRequest), arg0) -} - -// GetPatchBaselineWithContext mocks base method. -func (m *MockSSMAPI) GetPatchBaselineWithContext(arg0 context.Context, arg1 *ssm.GetPatchBaselineInput, arg2 ...request.Option) (*ssm.GetPatchBaselineOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetPatchBaselineWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetPatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetPatchBaselineWithContext indicates an expected call of GetPatchBaselineWithContext. -func (mr *MockSSMAPIMockRecorder) GetPatchBaselineWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatchBaselineWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetPatchBaselineWithContext), varargs...) -} - -// GetResourcePolicies mocks base method. -func (m *MockSSMAPI) GetResourcePolicies(arg0 *ssm.GetResourcePoliciesInput) (*ssm.GetResourcePoliciesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetResourcePolicies", arg0) - ret0, _ := ret[0].(*ssm.GetResourcePoliciesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetResourcePolicies indicates an expected call of GetResourcePolicies. -func (mr *MockSSMAPIMockRecorder) GetResourcePolicies(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicies", reflect.TypeOf((*MockSSMAPI)(nil).GetResourcePolicies), arg0) -} - -// GetResourcePoliciesPages mocks base method. -func (m *MockSSMAPI) GetResourcePoliciesPages(arg0 *ssm.GetResourcePoliciesInput, arg1 func(*ssm.GetResourcePoliciesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetResourcePoliciesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetResourcePoliciesPages indicates an expected call of GetResourcePoliciesPages. -func (mr *MockSSMAPIMockRecorder) GetResourcePoliciesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePoliciesPages", reflect.TypeOf((*MockSSMAPI)(nil).GetResourcePoliciesPages), arg0, arg1) -} - -// GetResourcePoliciesPagesWithContext mocks base method. -func (m *MockSSMAPI) GetResourcePoliciesPagesWithContext(arg0 context.Context, arg1 *ssm.GetResourcePoliciesInput, arg2 func(*ssm.GetResourcePoliciesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetResourcePoliciesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetResourcePoliciesPagesWithContext indicates an expected call of GetResourcePoliciesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) GetResourcePoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePoliciesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetResourcePoliciesPagesWithContext), varargs...) -} - -// GetResourcePoliciesRequest mocks base method. -func (m *MockSSMAPI) GetResourcePoliciesRequest(arg0 *ssm.GetResourcePoliciesInput) (*request.Request, *ssm.GetResourcePoliciesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetResourcePoliciesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetResourcePoliciesOutput) - return ret0, ret1 -} - -// GetResourcePoliciesRequest indicates an expected call of GetResourcePoliciesRequest. -func (mr *MockSSMAPIMockRecorder) GetResourcePoliciesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePoliciesRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetResourcePoliciesRequest), arg0) -} - -// GetResourcePoliciesWithContext mocks base method. -func (m *MockSSMAPI) GetResourcePoliciesWithContext(arg0 context.Context, arg1 *ssm.GetResourcePoliciesInput, arg2 ...request.Option) (*ssm.GetResourcePoliciesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetResourcePoliciesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetResourcePoliciesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetResourcePoliciesWithContext indicates an expected call of GetResourcePoliciesWithContext. -func (mr *MockSSMAPIMockRecorder) GetResourcePoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePoliciesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetResourcePoliciesWithContext), varargs...) -} - -// GetServiceSetting mocks base method. -func (m *MockSSMAPI) GetServiceSetting(arg0 *ssm.GetServiceSettingInput) (*ssm.GetServiceSettingOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetServiceSetting", arg0) - ret0, _ := ret[0].(*ssm.GetServiceSettingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetServiceSetting indicates an expected call of GetServiceSetting. -func (mr *MockSSMAPIMockRecorder) GetServiceSetting(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceSetting", reflect.TypeOf((*MockSSMAPI)(nil).GetServiceSetting), arg0) -} - -// GetServiceSettingRequest mocks base method. -func (m *MockSSMAPI) GetServiceSettingRequest(arg0 *ssm.GetServiceSettingInput) (*request.Request, *ssm.GetServiceSettingOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetServiceSettingRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.GetServiceSettingOutput) - return ret0, ret1 -} - -// GetServiceSettingRequest indicates an expected call of GetServiceSettingRequest. -func (mr *MockSSMAPIMockRecorder) GetServiceSettingRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceSettingRequest", reflect.TypeOf((*MockSSMAPI)(nil).GetServiceSettingRequest), arg0) -} - -// GetServiceSettingWithContext mocks base method. -func (m *MockSSMAPI) GetServiceSettingWithContext(arg0 context.Context, arg1 *ssm.GetServiceSettingInput, arg2 ...request.Option) (*ssm.GetServiceSettingOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetServiceSettingWithContext", varargs...) - ret0, _ := ret[0].(*ssm.GetServiceSettingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetServiceSettingWithContext indicates an expected call of GetServiceSettingWithContext. -func (mr *MockSSMAPIMockRecorder) GetServiceSettingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceSettingWithContext", reflect.TypeOf((*MockSSMAPI)(nil).GetServiceSettingWithContext), varargs...) -} - -// LabelParameterVersion mocks base method. -func (m *MockSSMAPI) LabelParameterVersion(arg0 *ssm.LabelParameterVersionInput) (*ssm.LabelParameterVersionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LabelParameterVersion", arg0) - ret0, _ := ret[0].(*ssm.LabelParameterVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LabelParameterVersion indicates an expected call of LabelParameterVersion. -func (mr *MockSSMAPIMockRecorder) LabelParameterVersion(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelParameterVersion", reflect.TypeOf((*MockSSMAPI)(nil).LabelParameterVersion), arg0) -} - -// LabelParameterVersionRequest mocks base method. -func (m *MockSSMAPI) LabelParameterVersionRequest(arg0 *ssm.LabelParameterVersionInput) (*request.Request, *ssm.LabelParameterVersionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LabelParameterVersionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.LabelParameterVersionOutput) - return ret0, ret1 -} - -// LabelParameterVersionRequest indicates an expected call of LabelParameterVersionRequest. -func (mr *MockSSMAPIMockRecorder) LabelParameterVersionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelParameterVersionRequest", reflect.TypeOf((*MockSSMAPI)(nil).LabelParameterVersionRequest), arg0) -} - -// LabelParameterVersionWithContext mocks base method. -func (m *MockSSMAPI) LabelParameterVersionWithContext(arg0 context.Context, arg1 *ssm.LabelParameterVersionInput, arg2 ...request.Option) (*ssm.LabelParameterVersionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "LabelParameterVersionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.LabelParameterVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LabelParameterVersionWithContext indicates an expected call of LabelParameterVersionWithContext. -func (mr *MockSSMAPIMockRecorder) LabelParameterVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelParameterVersionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).LabelParameterVersionWithContext), varargs...) -} - -// ListAssociationVersions mocks base method. -func (m *MockSSMAPI) ListAssociationVersions(arg0 *ssm.ListAssociationVersionsInput) (*ssm.ListAssociationVersionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAssociationVersions", arg0) - ret0, _ := ret[0].(*ssm.ListAssociationVersionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListAssociationVersions indicates an expected call of ListAssociationVersions. -func (mr *MockSSMAPIMockRecorder) ListAssociationVersions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationVersions", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationVersions), arg0) -} - -// ListAssociationVersionsPages mocks base method. -func (m *MockSSMAPI) ListAssociationVersionsPages(arg0 *ssm.ListAssociationVersionsInput, arg1 func(*ssm.ListAssociationVersionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAssociationVersionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListAssociationVersionsPages indicates an expected call of ListAssociationVersionsPages. -func (mr *MockSSMAPIMockRecorder) ListAssociationVersionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationVersionsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationVersionsPages), arg0, arg1) -} - -// ListAssociationVersionsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListAssociationVersionsPagesWithContext(arg0 context.Context, arg1 *ssm.ListAssociationVersionsInput, arg2 func(*ssm.ListAssociationVersionsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListAssociationVersionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListAssociationVersionsPagesWithContext indicates an expected call of ListAssociationVersionsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListAssociationVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationVersionsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationVersionsPagesWithContext), varargs...) -} - -// ListAssociationVersionsRequest mocks base method. -func (m *MockSSMAPI) ListAssociationVersionsRequest(arg0 *ssm.ListAssociationVersionsInput) (*request.Request, *ssm.ListAssociationVersionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAssociationVersionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListAssociationVersionsOutput) - return ret0, ret1 -} - -// ListAssociationVersionsRequest indicates an expected call of ListAssociationVersionsRequest. -func (mr *MockSSMAPIMockRecorder) ListAssociationVersionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationVersionsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationVersionsRequest), arg0) -} - -// ListAssociationVersionsWithContext mocks base method. -func (m *MockSSMAPI) ListAssociationVersionsWithContext(arg0 context.Context, arg1 *ssm.ListAssociationVersionsInput, arg2 ...request.Option) (*ssm.ListAssociationVersionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListAssociationVersionsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListAssociationVersionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListAssociationVersionsWithContext indicates an expected call of ListAssociationVersionsWithContext. -func (mr *MockSSMAPIMockRecorder) ListAssociationVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationVersionsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationVersionsWithContext), varargs...) -} - -// ListAssociations mocks base method. -func (m *MockSSMAPI) ListAssociations(arg0 *ssm.ListAssociationsInput) (*ssm.ListAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAssociations", arg0) - ret0, _ := ret[0].(*ssm.ListAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListAssociations indicates an expected call of ListAssociations. -func (mr *MockSSMAPIMockRecorder) ListAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociations", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociations), arg0) -} - -// ListAssociationsPages mocks base method. -func (m *MockSSMAPI) ListAssociationsPages(arg0 *ssm.ListAssociationsInput, arg1 func(*ssm.ListAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListAssociationsPages indicates an expected call of ListAssociationsPages. -func (mr *MockSSMAPIMockRecorder) ListAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationsPages), arg0, arg1) -} - -// ListAssociationsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListAssociationsPagesWithContext(arg0 context.Context, arg1 *ssm.ListAssociationsInput, arg2 func(*ssm.ListAssociationsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListAssociationsPagesWithContext indicates an expected call of ListAssociationsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationsPagesWithContext), varargs...) -} - -// ListAssociationsRequest mocks base method. -func (m *MockSSMAPI) ListAssociationsRequest(arg0 *ssm.ListAssociationsInput) (*request.Request, *ssm.ListAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListAssociationsOutput) - return ret0, ret1 -} - -// ListAssociationsRequest indicates an expected call of ListAssociationsRequest. -func (mr *MockSSMAPIMockRecorder) ListAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationsRequest), arg0) -} - -// ListAssociationsWithContext mocks base method. -func (m *MockSSMAPI) ListAssociationsWithContext(arg0 context.Context, arg1 *ssm.ListAssociationsInput, arg2 ...request.Option) (*ssm.ListAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListAssociationsWithContext indicates an expected call of ListAssociationsWithContext. -func (mr *MockSSMAPIMockRecorder) ListAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssociationsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListAssociationsWithContext), varargs...) -} - -// ListCommandInvocations mocks base method. -func (m *MockSSMAPI) ListCommandInvocations(arg0 *ssm.ListCommandInvocationsInput) (*ssm.ListCommandInvocationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListCommandInvocations", arg0) - ret0, _ := ret[0].(*ssm.ListCommandInvocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListCommandInvocations indicates an expected call of ListCommandInvocations. -func (mr *MockSSMAPIMockRecorder) ListCommandInvocations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandInvocations", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandInvocations), arg0) -} - -// ListCommandInvocationsPages mocks base method. -func (m *MockSSMAPI) ListCommandInvocationsPages(arg0 *ssm.ListCommandInvocationsInput, arg1 func(*ssm.ListCommandInvocationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListCommandInvocationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListCommandInvocationsPages indicates an expected call of ListCommandInvocationsPages. -func (mr *MockSSMAPIMockRecorder) ListCommandInvocationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandInvocationsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandInvocationsPages), arg0, arg1) -} - -// ListCommandInvocationsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListCommandInvocationsPagesWithContext(arg0 context.Context, arg1 *ssm.ListCommandInvocationsInput, arg2 func(*ssm.ListCommandInvocationsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListCommandInvocationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListCommandInvocationsPagesWithContext indicates an expected call of ListCommandInvocationsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListCommandInvocationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandInvocationsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandInvocationsPagesWithContext), varargs...) -} - -// ListCommandInvocationsRequest mocks base method. -func (m *MockSSMAPI) ListCommandInvocationsRequest(arg0 *ssm.ListCommandInvocationsInput) (*request.Request, *ssm.ListCommandInvocationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListCommandInvocationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListCommandInvocationsOutput) - return ret0, ret1 -} - -// ListCommandInvocationsRequest indicates an expected call of ListCommandInvocationsRequest. -func (mr *MockSSMAPIMockRecorder) ListCommandInvocationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandInvocationsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandInvocationsRequest), arg0) -} - -// ListCommandInvocationsWithContext mocks base method. -func (m *MockSSMAPI) ListCommandInvocationsWithContext(arg0 context.Context, arg1 *ssm.ListCommandInvocationsInput, arg2 ...request.Option) (*ssm.ListCommandInvocationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListCommandInvocationsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListCommandInvocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListCommandInvocationsWithContext indicates an expected call of ListCommandInvocationsWithContext. -func (mr *MockSSMAPIMockRecorder) ListCommandInvocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandInvocationsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandInvocationsWithContext), varargs...) -} - -// ListCommands mocks base method. -func (m *MockSSMAPI) ListCommands(arg0 *ssm.ListCommandsInput) (*ssm.ListCommandsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListCommands", arg0) - ret0, _ := ret[0].(*ssm.ListCommandsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListCommands indicates an expected call of ListCommands. -func (mr *MockSSMAPIMockRecorder) ListCommands(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommands", reflect.TypeOf((*MockSSMAPI)(nil).ListCommands), arg0) -} - -// ListCommandsPages mocks base method. -func (m *MockSSMAPI) ListCommandsPages(arg0 *ssm.ListCommandsInput, arg1 func(*ssm.ListCommandsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListCommandsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListCommandsPages indicates an expected call of ListCommandsPages. -func (mr *MockSSMAPIMockRecorder) ListCommandsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandsPages), arg0, arg1) -} - -// ListCommandsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListCommandsPagesWithContext(arg0 context.Context, arg1 *ssm.ListCommandsInput, arg2 func(*ssm.ListCommandsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListCommandsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListCommandsPagesWithContext indicates an expected call of ListCommandsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListCommandsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandsPagesWithContext), varargs...) -} - -// ListCommandsRequest mocks base method. -func (m *MockSSMAPI) ListCommandsRequest(arg0 *ssm.ListCommandsInput) (*request.Request, *ssm.ListCommandsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListCommandsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListCommandsOutput) - return ret0, ret1 -} - -// ListCommandsRequest indicates an expected call of ListCommandsRequest. -func (mr *MockSSMAPIMockRecorder) ListCommandsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandsRequest), arg0) -} - -// ListCommandsWithContext mocks base method. -func (m *MockSSMAPI) ListCommandsWithContext(arg0 context.Context, arg1 *ssm.ListCommandsInput, arg2 ...request.Option) (*ssm.ListCommandsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListCommandsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListCommandsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListCommandsWithContext indicates an expected call of ListCommandsWithContext. -func (mr *MockSSMAPIMockRecorder) ListCommandsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListCommandsWithContext), varargs...) -} - -// ListComplianceItems mocks base method. -func (m *MockSSMAPI) ListComplianceItems(arg0 *ssm.ListComplianceItemsInput) (*ssm.ListComplianceItemsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListComplianceItems", arg0) - ret0, _ := ret[0].(*ssm.ListComplianceItemsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListComplianceItems indicates an expected call of ListComplianceItems. -func (mr *MockSSMAPIMockRecorder) ListComplianceItems(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceItems", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceItems), arg0) -} - -// ListComplianceItemsPages mocks base method. -func (m *MockSSMAPI) ListComplianceItemsPages(arg0 *ssm.ListComplianceItemsInput, arg1 func(*ssm.ListComplianceItemsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListComplianceItemsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListComplianceItemsPages indicates an expected call of ListComplianceItemsPages. -func (mr *MockSSMAPIMockRecorder) ListComplianceItemsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceItemsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceItemsPages), arg0, arg1) -} - -// ListComplianceItemsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListComplianceItemsPagesWithContext(arg0 context.Context, arg1 *ssm.ListComplianceItemsInput, arg2 func(*ssm.ListComplianceItemsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListComplianceItemsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListComplianceItemsPagesWithContext indicates an expected call of ListComplianceItemsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListComplianceItemsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceItemsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceItemsPagesWithContext), varargs...) -} - -// ListComplianceItemsRequest mocks base method. -func (m *MockSSMAPI) ListComplianceItemsRequest(arg0 *ssm.ListComplianceItemsInput) (*request.Request, *ssm.ListComplianceItemsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListComplianceItemsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListComplianceItemsOutput) - return ret0, ret1 -} - -// ListComplianceItemsRequest indicates an expected call of ListComplianceItemsRequest. -func (mr *MockSSMAPIMockRecorder) ListComplianceItemsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceItemsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceItemsRequest), arg0) -} - -// ListComplianceItemsWithContext mocks base method. -func (m *MockSSMAPI) ListComplianceItemsWithContext(arg0 context.Context, arg1 *ssm.ListComplianceItemsInput, arg2 ...request.Option) (*ssm.ListComplianceItemsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListComplianceItemsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListComplianceItemsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListComplianceItemsWithContext indicates an expected call of ListComplianceItemsWithContext. -func (mr *MockSSMAPIMockRecorder) ListComplianceItemsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceItemsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceItemsWithContext), varargs...) -} - -// ListComplianceSummaries mocks base method. -func (m *MockSSMAPI) ListComplianceSummaries(arg0 *ssm.ListComplianceSummariesInput) (*ssm.ListComplianceSummariesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListComplianceSummaries", arg0) - ret0, _ := ret[0].(*ssm.ListComplianceSummariesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListComplianceSummaries indicates an expected call of ListComplianceSummaries. -func (mr *MockSSMAPIMockRecorder) ListComplianceSummaries(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceSummaries", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceSummaries), arg0) -} - -// ListComplianceSummariesPages mocks base method. -func (m *MockSSMAPI) ListComplianceSummariesPages(arg0 *ssm.ListComplianceSummariesInput, arg1 func(*ssm.ListComplianceSummariesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListComplianceSummariesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListComplianceSummariesPages indicates an expected call of ListComplianceSummariesPages. -func (mr *MockSSMAPIMockRecorder) ListComplianceSummariesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceSummariesPages", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceSummariesPages), arg0, arg1) -} - -// ListComplianceSummariesPagesWithContext mocks base method. -func (m *MockSSMAPI) ListComplianceSummariesPagesWithContext(arg0 context.Context, arg1 *ssm.ListComplianceSummariesInput, arg2 func(*ssm.ListComplianceSummariesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListComplianceSummariesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListComplianceSummariesPagesWithContext indicates an expected call of ListComplianceSummariesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListComplianceSummariesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceSummariesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceSummariesPagesWithContext), varargs...) -} - -// ListComplianceSummariesRequest mocks base method. -func (m *MockSSMAPI) ListComplianceSummariesRequest(arg0 *ssm.ListComplianceSummariesInput) (*request.Request, *ssm.ListComplianceSummariesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListComplianceSummariesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListComplianceSummariesOutput) - return ret0, ret1 -} - -// ListComplianceSummariesRequest indicates an expected call of ListComplianceSummariesRequest. -func (mr *MockSSMAPIMockRecorder) ListComplianceSummariesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceSummariesRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceSummariesRequest), arg0) -} - -// ListComplianceSummariesWithContext mocks base method. -func (m *MockSSMAPI) ListComplianceSummariesWithContext(arg0 context.Context, arg1 *ssm.ListComplianceSummariesInput, arg2 ...request.Option) (*ssm.ListComplianceSummariesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListComplianceSummariesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListComplianceSummariesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListComplianceSummariesWithContext indicates an expected call of ListComplianceSummariesWithContext. -func (mr *MockSSMAPIMockRecorder) ListComplianceSummariesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComplianceSummariesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListComplianceSummariesWithContext), varargs...) -} - -// ListDocumentMetadataHistory mocks base method. -func (m *MockSSMAPI) ListDocumentMetadataHistory(arg0 *ssm.ListDocumentMetadataHistoryInput) (*ssm.ListDocumentMetadataHistoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDocumentMetadataHistory", arg0) - ret0, _ := ret[0].(*ssm.ListDocumentMetadataHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListDocumentMetadataHistory indicates an expected call of ListDocumentMetadataHistory. -func (mr *MockSSMAPIMockRecorder) ListDocumentMetadataHistory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentMetadataHistory", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentMetadataHistory), arg0) -} - -// ListDocumentMetadataHistoryRequest mocks base method. -func (m *MockSSMAPI) ListDocumentMetadataHistoryRequest(arg0 *ssm.ListDocumentMetadataHistoryInput) (*request.Request, *ssm.ListDocumentMetadataHistoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDocumentMetadataHistoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListDocumentMetadataHistoryOutput) - return ret0, ret1 -} - -// ListDocumentMetadataHistoryRequest indicates an expected call of ListDocumentMetadataHistoryRequest. -func (mr *MockSSMAPIMockRecorder) ListDocumentMetadataHistoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentMetadataHistoryRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentMetadataHistoryRequest), arg0) -} - -// ListDocumentMetadataHistoryWithContext mocks base method. -func (m *MockSSMAPI) ListDocumentMetadataHistoryWithContext(arg0 context.Context, arg1 *ssm.ListDocumentMetadataHistoryInput, arg2 ...request.Option) (*ssm.ListDocumentMetadataHistoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListDocumentMetadataHistoryWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListDocumentMetadataHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListDocumentMetadataHistoryWithContext indicates an expected call of ListDocumentMetadataHistoryWithContext. -func (mr *MockSSMAPIMockRecorder) ListDocumentMetadataHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentMetadataHistoryWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentMetadataHistoryWithContext), varargs...) -} - -// ListDocumentVersions mocks base method. -func (m *MockSSMAPI) ListDocumentVersions(arg0 *ssm.ListDocumentVersionsInput) (*ssm.ListDocumentVersionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDocumentVersions", arg0) - ret0, _ := ret[0].(*ssm.ListDocumentVersionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListDocumentVersions indicates an expected call of ListDocumentVersions. -func (mr *MockSSMAPIMockRecorder) ListDocumentVersions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentVersions", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentVersions), arg0) -} - -// ListDocumentVersionsPages mocks base method. -func (m *MockSSMAPI) ListDocumentVersionsPages(arg0 *ssm.ListDocumentVersionsInput, arg1 func(*ssm.ListDocumentVersionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDocumentVersionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListDocumentVersionsPages indicates an expected call of ListDocumentVersionsPages. -func (mr *MockSSMAPIMockRecorder) ListDocumentVersionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentVersionsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentVersionsPages), arg0, arg1) -} - -// ListDocumentVersionsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListDocumentVersionsPagesWithContext(arg0 context.Context, arg1 *ssm.ListDocumentVersionsInput, arg2 func(*ssm.ListDocumentVersionsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListDocumentVersionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListDocumentVersionsPagesWithContext indicates an expected call of ListDocumentVersionsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListDocumentVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentVersionsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentVersionsPagesWithContext), varargs...) -} - -// ListDocumentVersionsRequest mocks base method. -func (m *MockSSMAPI) ListDocumentVersionsRequest(arg0 *ssm.ListDocumentVersionsInput) (*request.Request, *ssm.ListDocumentVersionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDocumentVersionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListDocumentVersionsOutput) - return ret0, ret1 -} - -// ListDocumentVersionsRequest indicates an expected call of ListDocumentVersionsRequest. -func (mr *MockSSMAPIMockRecorder) ListDocumentVersionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentVersionsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentVersionsRequest), arg0) -} - -// ListDocumentVersionsWithContext mocks base method. -func (m *MockSSMAPI) ListDocumentVersionsWithContext(arg0 context.Context, arg1 *ssm.ListDocumentVersionsInput, arg2 ...request.Option) (*ssm.ListDocumentVersionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListDocumentVersionsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListDocumentVersionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListDocumentVersionsWithContext indicates an expected call of ListDocumentVersionsWithContext. -func (mr *MockSSMAPIMockRecorder) ListDocumentVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentVersionsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentVersionsWithContext), varargs...) -} - -// ListDocuments mocks base method. -func (m *MockSSMAPI) ListDocuments(arg0 *ssm.ListDocumentsInput) (*ssm.ListDocumentsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDocuments", arg0) - ret0, _ := ret[0].(*ssm.ListDocumentsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListDocuments indicates an expected call of ListDocuments. -func (mr *MockSSMAPIMockRecorder) ListDocuments(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocuments", reflect.TypeOf((*MockSSMAPI)(nil).ListDocuments), arg0) -} - -// ListDocumentsPages mocks base method. -func (m *MockSSMAPI) ListDocumentsPages(arg0 *ssm.ListDocumentsInput, arg1 func(*ssm.ListDocumentsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDocumentsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListDocumentsPages indicates an expected call of ListDocumentsPages. -func (mr *MockSSMAPIMockRecorder) ListDocumentsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentsPages), arg0, arg1) -} - -// ListDocumentsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListDocumentsPagesWithContext(arg0 context.Context, arg1 *ssm.ListDocumentsInput, arg2 func(*ssm.ListDocumentsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListDocumentsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListDocumentsPagesWithContext indicates an expected call of ListDocumentsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListDocumentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentsPagesWithContext), varargs...) -} - -// ListDocumentsRequest mocks base method. -func (m *MockSSMAPI) ListDocumentsRequest(arg0 *ssm.ListDocumentsInput) (*request.Request, *ssm.ListDocumentsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDocumentsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListDocumentsOutput) - return ret0, ret1 -} - -// ListDocumentsRequest indicates an expected call of ListDocumentsRequest. -func (mr *MockSSMAPIMockRecorder) ListDocumentsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentsRequest), arg0) -} - -// ListDocumentsWithContext mocks base method. -func (m *MockSSMAPI) ListDocumentsWithContext(arg0 context.Context, arg1 *ssm.ListDocumentsInput, arg2 ...request.Option) (*ssm.ListDocumentsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListDocumentsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListDocumentsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListDocumentsWithContext indicates an expected call of ListDocumentsWithContext. -func (mr *MockSSMAPIMockRecorder) ListDocumentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocumentsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListDocumentsWithContext), varargs...) -} - -// ListInventoryEntries mocks base method. -func (m *MockSSMAPI) ListInventoryEntries(arg0 *ssm.ListInventoryEntriesInput) (*ssm.ListInventoryEntriesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListInventoryEntries", arg0) - ret0, _ := ret[0].(*ssm.ListInventoryEntriesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListInventoryEntries indicates an expected call of ListInventoryEntries. -func (mr *MockSSMAPIMockRecorder) ListInventoryEntries(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInventoryEntries", reflect.TypeOf((*MockSSMAPI)(nil).ListInventoryEntries), arg0) -} - -// ListInventoryEntriesRequest mocks base method. -func (m *MockSSMAPI) ListInventoryEntriesRequest(arg0 *ssm.ListInventoryEntriesInput) (*request.Request, *ssm.ListInventoryEntriesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListInventoryEntriesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListInventoryEntriesOutput) - return ret0, ret1 -} - -// ListInventoryEntriesRequest indicates an expected call of ListInventoryEntriesRequest. -func (mr *MockSSMAPIMockRecorder) ListInventoryEntriesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInventoryEntriesRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListInventoryEntriesRequest), arg0) -} - -// ListInventoryEntriesWithContext mocks base method. -func (m *MockSSMAPI) ListInventoryEntriesWithContext(arg0 context.Context, arg1 *ssm.ListInventoryEntriesInput, arg2 ...request.Option) (*ssm.ListInventoryEntriesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListInventoryEntriesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListInventoryEntriesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListInventoryEntriesWithContext indicates an expected call of ListInventoryEntriesWithContext. -func (mr *MockSSMAPIMockRecorder) ListInventoryEntriesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInventoryEntriesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListInventoryEntriesWithContext), varargs...) -} - -// ListOpsItemEvents mocks base method. -func (m *MockSSMAPI) ListOpsItemEvents(arg0 *ssm.ListOpsItemEventsInput) (*ssm.ListOpsItemEventsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsItemEvents", arg0) - ret0, _ := ret[0].(*ssm.ListOpsItemEventsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListOpsItemEvents indicates an expected call of ListOpsItemEvents. -func (mr *MockSSMAPIMockRecorder) ListOpsItemEvents(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemEvents", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemEvents), arg0) -} - -// ListOpsItemEventsPages mocks base method. -func (m *MockSSMAPI) ListOpsItemEventsPages(arg0 *ssm.ListOpsItemEventsInput, arg1 func(*ssm.ListOpsItemEventsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsItemEventsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListOpsItemEventsPages indicates an expected call of ListOpsItemEventsPages. -func (mr *MockSSMAPIMockRecorder) ListOpsItemEventsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemEventsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemEventsPages), arg0, arg1) -} - -// ListOpsItemEventsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListOpsItemEventsPagesWithContext(arg0 context.Context, arg1 *ssm.ListOpsItemEventsInput, arg2 func(*ssm.ListOpsItemEventsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListOpsItemEventsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListOpsItemEventsPagesWithContext indicates an expected call of ListOpsItemEventsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListOpsItemEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemEventsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemEventsPagesWithContext), varargs...) -} - -// ListOpsItemEventsRequest mocks base method. -func (m *MockSSMAPI) ListOpsItemEventsRequest(arg0 *ssm.ListOpsItemEventsInput) (*request.Request, *ssm.ListOpsItemEventsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsItemEventsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListOpsItemEventsOutput) - return ret0, ret1 -} - -// ListOpsItemEventsRequest indicates an expected call of ListOpsItemEventsRequest. -func (mr *MockSSMAPIMockRecorder) ListOpsItemEventsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemEventsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemEventsRequest), arg0) -} - -// ListOpsItemEventsWithContext mocks base method. -func (m *MockSSMAPI) ListOpsItemEventsWithContext(arg0 context.Context, arg1 *ssm.ListOpsItemEventsInput, arg2 ...request.Option) (*ssm.ListOpsItemEventsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListOpsItemEventsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListOpsItemEventsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListOpsItemEventsWithContext indicates an expected call of ListOpsItemEventsWithContext. -func (mr *MockSSMAPIMockRecorder) ListOpsItemEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemEventsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemEventsWithContext), varargs...) -} - -// ListOpsItemRelatedItems mocks base method. -func (m *MockSSMAPI) ListOpsItemRelatedItems(arg0 *ssm.ListOpsItemRelatedItemsInput) (*ssm.ListOpsItemRelatedItemsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsItemRelatedItems", arg0) - ret0, _ := ret[0].(*ssm.ListOpsItemRelatedItemsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListOpsItemRelatedItems indicates an expected call of ListOpsItemRelatedItems. -func (mr *MockSSMAPIMockRecorder) ListOpsItemRelatedItems(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemRelatedItems", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemRelatedItems), arg0) -} - -// ListOpsItemRelatedItemsPages mocks base method. -func (m *MockSSMAPI) ListOpsItemRelatedItemsPages(arg0 *ssm.ListOpsItemRelatedItemsInput, arg1 func(*ssm.ListOpsItemRelatedItemsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsItemRelatedItemsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListOpsItemRelatedItemsPages indicates an expected call of ListOpsItemRelatedItemsPages. -func (mr *MockSSMAPIMockRecorder) ListOpsItemRelatedItemsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemRelatedItemsPages", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemRelatedItemsPages), arg0, arg1) -} - -// ListOpsItemRelatedItemsPagesWithContext mocks base method. -func (m *MockSSMAPI) ListOpsItemRelatedItemsPagesWithContext(arg0 context.Context, arg1 *ssm.ListOpsItemRelatedItemsInput, arg2 func(*ssm.ListOpsItemRelatedItemsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListOpsItemRelatedItemsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListOpsItemRelatedItemsPagesWithContext indicates an expected call of ListOpsItemRelatedItemsPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListOpsItemRelatedItemsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemRelatedItemsPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemRelatedItemsPagesWithContext), varargs...) -} - -// ListOpsItemRelatedItemsRequest mocks base method. -func (m *MockSSMAPI) ListOpsItemRelatedItemsRequest(arg0 *ssm.ListOpsItemRelatedItemsInput) (*request.Request, *ssm.ListOpsItemRelatedItemsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsItemRelatedItemsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListOpsItemRelatedItemsOutput) - return ret0, ret1 -} - -// ListOpsItemRelatedItemsRequest indicates an expected call of ListOpsItemRelatedItemsRequest. -func (mr *MockSSMAPIMockRecorder) ListOpsItemRelatedItemsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemRelatedItemsRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemRelatedItemsRequest), arg0) -} - -// ListOpsItemRelatedItemsWithContext mocks base method. -func (m *MockSSMAPI) ListOpsItemRelatedItemsWithContext(arg0 context.Context, arg1 *ssm.ListOpsItemRelatedItemsInput, arg2 ...request.Option) (*ssm.ListOpsItemRelatedItemsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListOpsItemRelatedItemsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListOpsItemRelatedItemsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListOpsItemRelatedItemsWithContext indicates an expected call of ListOpsItemRelatedItemsWithContext. -func (mr *MockSSMAPIMockRecorder) ListOpsItemRelatedItemsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsItemRelatedItemsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsItemRelatedItemsWithContext), varargs...) -} - -// ListOpsMetadata mocks base method. -func (m *MockSSMAPI) ListOpsMetadata(arg0 *ssm.ListOpsMetadataInput) (*ssm.ListOpsMetadataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsMetadata", arg0) - ret0, _ := ret[0].(*ssm.ListOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListOpsMetadata indicates an expected call of ListOpsMetadata. -func (mr *MockSSMAPIMockRecorder) ListOpsMetadata(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsMetadata", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsMetadata), arg0) -} - -// ListOpsMetadataPages mocks base method. -func (m *MockSSMAPI) ListOpsMetadataPages(arg0 *ssm.ListOpsMetadataInput, arg1 func(*ssm.ListOpsMetadataOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsMetadataPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListOpsMetadataPages indicates an expected call of ListOpsMetadataPages. -func (mr *MockSSMAPIMockRecorder) ListOpsMetadataPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsMetadataPages", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsMetadataPages), arg0, arg1) -} - -// ListOpsMetadataPagesWithContext mocks base method. -func (m *MockSSMAPI) ListOpsMetadataPagesWithContext(arg0 context.Context, arg1 *ssm.ListOpsMetadataInput, arg2 func(*ssm.ListOpsMetadataOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListOpsMetadataPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListOpsMetadataPagesWithContext indicates an expected call of ListOpsMetadataPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListOpsMetadataPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsMetadataPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsMetadataPagesWithContext), varargs...) -} - -// ListOpsMetadataRequest mocks base method. -func (m *MockSSMAPI) ListOpsMetadataRequest(arg0 *ssm.ListOpsMetadataInput) (*request.Request, *ssm.ListOpsMetadataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListOpsMetadataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListOpsMetadataOutput) - return ret0, ret1 -} - -// ListOpsMetadataRequest indicates an expected call of ListOpsMetadataRequest. -func (mr *MockSSMAPIMockRecorder) ListOpsMetadataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsMetadataRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsMetadataRequest), arg0) -} - -// ListOpsMetadataWithContext mocks base method. -func (m *MockSSMAPI) ListOpsMetadataWithContext(arg0 context.Context, arg1 *ssm.ListOpsMetadataInput, arg2 ...request.Option) (*ssm.ListOpsMetadataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListOpsMetadataWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListOpsMetadataWithContext indicates an expected call of ListOpsMetadataWithContext. -func (mr *MockSSMAPIMockRecorder) ListOpsMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpsMetadataWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListOpsMetadataWithContext), varargs...) -} - -// ListResourceComplianceSummaries mocks base method. -func (m *MockSSMAPI) ListResourceComplianceSummaries(arg0 *ssm.ListResourceComplianceSummariesInput) (*ssm.ListResourceComplianceSummariesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourceComplianceSummaries", arg0) - ret0, _ := ret[0].(*ssm.ListResourceComplianceSummariesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListResourceComplianceSummaries indicates an expected call of ListResourceComplianceSummaries. -func (mr *MockSSMAPIMockRecorder) ListResourceComplianceSummaries(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceComplianceSummaries", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceComplianceSummaries), arg0) -} - -// ListResourceComplianceSummariesPages mocks base method. -func (m *MockSSMAPI) ListResourceComplianceSummariesPages(arg0 *ssm.ListResourceComplianceSummariesInput, arg1 func(*ssm.ListResourceComplianceSummariesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourceComplianceSummariesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListResourceComplianceSummariesPages indicates an expected call of ListResourceComplianceSummariesPages. -func (mr *MockSSMAPIMockRecorder) ListResourceComplianceSummariesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceComplianceSummariesPages", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceComplianceSummariesPages), arg0, arg1) -} - -// ListResourceComplianceSummariesPagesWithContext mocks base method. -func (m *MockSSMAPI) ListResourceComplianceSummariesPagesWithContext(arg0 context.Context, arg1 *ssm.ListResourceComplianceSummariesInput, arg2 func(*ssm.ListResourceComplianceSummariesOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListResourceComplianceSummariesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListResourceComplianceSummariesPagesWithContext indicates an expected call of ListResourceComplianceSummariesPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListResourceComplianceSummariesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceComplianceSummariesPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceComplianceSummariesPagesWithContext), varargs...) -} - -// ListResourceComplianceSummariesRequest mocks base method. -func (m *MockSSMAPI) ListResourceComplianceSummariesRequest(arg0 *ssm.ListResourceComplianceSummariesInput) (*request.Request, *ssm.ListResourceComplianceSummariesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourceComplianceSummariesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListResourceComplianceSummariesOutput) - return ret0, ret1 -} - -// ListResourceComplianceSummariesRequest indicates an expected call of ListResourceComplianceSummariesRequest. -func (mr *MockSSMAPIMockRecorder) ListResourceComplianceSummariesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceComplianceSummariesRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceComplianceSummariesRequest), arg0) -} - -// ListResourceComplianceSummariesWithContext mocks base method. -func (m *MockSSMAPI) ListResourceComplianceSummariesWithContext(arg0 context.Context, arg1 *ssm.ListResourceComplianceSummariesInput, arg2 ...request.Option) (*ssm.ListResourceComplianceSummariesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListResourceComplianceSummariesWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListResourceComplianceSummariesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListResourceComplianceSummariesWithContext indicates an expected call of ListResourceComplianceSummariesWithContext. -func (mr *MockSSMAPIMockRecorder) ListResourceComplianceSummariesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceComplianceSummariesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceComplianceSummariesWithContext), varargs...) -} - -// ListResourceDataSync mocks base method. -func (m *MockSSMAPI) ListResourceDataSync(arg0 *ssm.ListResourceDataSyncInput) (*ssm.ListResourceDataSyncOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourceDataSync", arg0) - ret0, _ := ret[0].(*ssm.ListResourceDataSyncOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListResourceDataSync indicates an expected call of ListResourceDataSync. -func (mr *MockSSMAPIMockRecorder) ListResourceDataSync(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceDataSync", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceDataSync), arg0) -} - -// ListResourceDataSyncPages mocks base method. -func (m *MockSSMAPI) ListResourceDataSyncPages(arg0 *ssm.ListResourceDataSyncInput, arg1 func(*ssm.ListResourceDataSyncOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourceDataSyncPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListResourceDataSyncPages indicates an expected call of ListResourceDataSyncPages. -func (mr *MockSSMAPIMockRecorder) ListResourceDataSyncPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceDataSyncPages", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceDataSyncPages), arg0, arg1) -} - -// ListResourceDataSyncPagesWithContext mocks base method. -func (m *MockSSMAPI) ListResourceDataSyncPagesWithContext(arg0 context.Context, arg1 *ssm.ListResourceDataSyncInput, arg2 func(*ssm.ListResourceDataSyncOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListResourceDataSyncPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListResourceDataSyncPagesWithContext indicates an expected call of ListResourceDataSyncPagesWithContext. -func (mr *MockSSMAPIMockRecorder) ListResourceDataSyncPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceDataSyncPagesWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceDataSyncPagesWithContext), varargs...) -} - -// ListResourceDataSyncRequest mocks base method. -func (m *MockSSMAPI) ListResourceDataSyncRequest(arg0 *ssm.ListResourceDataSyncInput) (*request.Request, *ssm.ListResourceDataSyncOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourceDataSyncRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListResourceDataSyncOutput) - return ret0, ret1 -} - -// ListResourceDataSyncRequest indicates an expected call of ListResourceDataSyncRequest. -func (mr *MockSSMAPIMockRecorder) ListResourceDataSyncRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceDataSyncRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceDataSyncRequest), arg0) -} - -// ListResourceDataSyncWithContext mocks base method. -func (m *MockSSMAPI) ListResourceDataSyncWithContext(arg0 context.Context, arg1 *ssm.ListResourceDataSyncInput, arg2 ...request.Option) (*ssm.ListResourceDataSyncOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListResourceDataSyncWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListResourceDataSyncOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListResourceDataSyncWithContext indicates an expected call of ListResourceDataSyncWithContext. -func (mr *MockSSMAPIMockRecorder) ListResourceDataSyncWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceDataSyncWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListResourceDataSyncWithContext), varargs...) -} - -// ListTagsForResource mocks base method. -func (m *MockSSMAPI) ListTagsForResource(arg0 *ssm.ListTagsForResourceInput) (*ssm.ListTagsForResourceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListTagsForResource", arg0) - ret0, _ := ret[0].(*ssm.ListTagsForResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListTagsForResource indicates an expected call of ListTagsForResource. -func (mr *MockSSMAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockSSMAPI)(nil).ListTagsForResource), arg0) -} - -// ListTagsForResourceRequest mocks base method. -func (m *MockSSMAPI) ListTagsForResourceRequest(arg0 *ssm.ListTagsForResourceInput) (*request.Request, *ssm.ListTagsForResourceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ListTagsForResourceOutput) - return ret0, ret1 -} - -// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest. -func (mr *MockSSMAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockSSMAPI)(nil).ListTagsForResourceRequest), arg0) -} - -// ListTagsForResourceWithContext mocks base method. -func (m *MockSSMAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *ssm.ListTagsForResourceInput, arg2 ...request.Option) (*ssm.ListTagsForResourceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ListTagsForResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext. -func (mr *MockSSMAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ListTagsForResourceWithContext), varargs...) -} - -// ModifyDocumentPermission mocks base method. -func (m *MockSSMAPI) ModifyDocumentPermission(arg0 *ssm.ModifyDocumentPermissionInput) (*ssm.ModifyDocumentPermissionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyDocumentPermission", arg0) - ret0, _ := ret[0].(*ssm.ModifyDocumentPermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyDocumentPermission indicates an expected call of ModifyDocumentPermission. -func (mr *MockSSMAPIMockRecorder) ModifyDocumentPermission(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDocumentPermission", reflect.TypeOf((*MockSSMAPI)(nil).ModifyDocumentPermission), arg0) -} - -// ModifyDocumentPermissionRequest mocks base method. -func (m *MockSSMAPI) ModifyDocumentPermissionRequest(arg0 *ssm.ModifyDocumentPermissionInput) (*request.Request, *ssm.ModifyDocumentPermissionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyDocumentPermissionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ModifyDocumentPermissionOutput) - return ret0, ret1 -} - -// ModifyDocumentPermissionRequest indicates an expected call of ModifyDocumentPermissionRequest. -func (mr *MockSSMAPIMockRecorder) ModifyDocumentPermissionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDocumentPermissionRequest", reflect.TypeOf((*MockSSMAPI)(nil).ModifyDocumentPermissionRequest), arg0) -} - -// ModifyDocumentPermissionWithContext mocks base method. -func (m *MockSSMAPI) ModifyDocumentPermissionWithContext(arg0 context.Context, arg1 *ssm.ModifyDocumentPermissionInput, arg2 ...request.Option) (*ssm.ModifyDocumentPermissionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyDocumentPermissionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ModifyDocumentPermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyDocumentPermissionWithContext indicates an expected call of ModifyDocumentPermissionWithContext. -func (mr *MockSSMAPIMockRecorder) ModifyDocumentPermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDocumentPermissionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ModifyDocumentPermissionWithContext), varargs...) -} - -// PutComplianceItems mocks base method. -func (m *MockSSMAPI) PutComplianceItems(arg0 *ssm.PutComplianceItemsInput) (*ssm.PutComplianceItemsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutComplianceItems", arg0) - ret0, _ := ret[0].(*ssm.PutComplianceItemsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutComplianceItems indicates an expected call of PutComplianceItems. -func (mr *MockSSMAPIMockRecorder) PutComplianceItems(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutComplianceItems", reflect.TypeOf((*MockSSMAPI)(nil).PutComplianceItems), arg0) -} - -// PutComplianceItemsRequest mocks base method. -func (m *MockSSMAPI) PutComplianceItemsRequest(arg0 *ssm.PutComplianceItemsInput) (*request.Request, *ssm.PutComplianceItemsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutComplianceItemsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.PutComplianceItemsOutput) - return ret0, ret1 -} - -// PutComplianceItemsRequest indicates an expected call of PutComplianceItemsRequest. -func (mr *MockSSMAPIMockRecorder) PutComplianceItemsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutComplianceItemsRequest", reflect.TypeOf((*MockSSMAPI)(nil).PutComplianceItemsRequest), arg0) -} - -// PutComplianceItemsWithContext mocks base method. -func (m *MockSSMAPI) PutComplianceItemsWithContext(arg0 context.Context, arg1 *ssm.PutComplianceItemsInput, arg2 ...request.Option) (*ssm.PutComplianceItemsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PutComplianceItemsWithContext", varargs...) - ret0, _ := ret[0].(*ssm.PutComplianceItemsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutComplianceItemsWithContext indicates an expected call of PutComplianceItemsWithContext. -func (mr *MockSSMAPIMockRecorder) PutComplianceItemsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutComplianceItemsWithContext", reflect.TypeOf((*MockSSMAPI)(nil).PutComplianceItemsWithContext), varargs...) -} - -// PutInventory mocks base method. -func (m *MockSSMAPI) PutInventory(arg0 *ssm.PutInventoryInput) (*ssm.PutInventoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutInventory", arg0) - ret0, _ := ret[0].(*ssm.PutInventoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutInventory indicates an expected call of PutInventory. -func (mr *MockSSMAPIMockRecorder) PutInventory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutInventory", reflect.TypeOf((*MockSSMAPI)(nil).PutInventory), arg0) -} - -// PutInventoryRequest mocks base method. -func (m *MockSSMAPI) PutInventoryRequest(arg0 *ssm.PutInventoryInput) (*request.Request, *ssm.PutInventoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutInventoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.PutInventoryOutput) - return ret0, ret1 -} - -// PutInventoryRequest indicates an expected call of PutInventoryRequest. -func (mr *MockSSMAPIMockRecorder) PutInventoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutInventoryRequest", reflect.TypeOf((*MockSSMAPI)(nil).PutInventoryRequest), arg0) -} - -// PutInventoryWithContext mocks base method. -func (m *MockSSMAPI) PutInventoryWithContext(arg0 context.Context, arg1 *ssm.PutInventoryInput, arg2 ...request.Option) (*ssm.PutInventoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PutInventoryWithContext", varargs...) - ret0, _ := ret[0].(*ssm.PutInventoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutInventoryWithContext indicates an expected call of PutInventoryWithContext. -func (mr *MockSSMAPIMockRecorder) PutInventoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutInventoryWithContext", reflect.TypeOf((*MockSSMAPI)(nil).PutInventoryWithContext), varargs...) -} - -// PutParameter mocks base method. -func (m *MockSSMAPI) PutParameter(arg0 *ssm.PutParameterInput) (*ssm.PutParameterOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutParameter", arg0) - ret0, _ := ret[0].(*ssm.PutParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutParameter indicates an expected call of PutParameter. -func (mr *MockSSMAPIMockRecorder) PutParameter(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutParameter", reflect.TypeOf((*MockSSMAPI)(nil).PutParameter), arg0) -} - -// PutParameterRequest mocks base method. -func (m *MockSSMAPI) PutParameterRequest(arg0 *ssm.PutParameterInput) (*request.Request, *ssm.PutParameterOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutParameterRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.PutParameterOutput) - return ret0, ret1 -} - -// PutParameterRequest indicates an expected call of PutParameterRequest. -func (mr *MockSSMAPIMockRecorder) PutParameterRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutParameterRequest", reflect.TypeOf((*MockSSMAPI)(nil).PutParameterRequest), arg0) -} - -// PutParameterWithContext mocks base method. -func (m *MockSSMAPI) PutParameterWithContext(arg0 context.Context, arg1 *ssm.PutParameterInput, arg2 ...request.Option) (*ssm.PutParameterOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PutParameterWithContext", varargs...) - ret0, _ := ret[0].(*ssm.PutParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutParameterWithContext indicates an expected call of PutParameterWithContext. -func (mr *MockSSMAPIMockRecorder) PutParameterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutParameterWithContext", reflect.TypeOf((*MockSSMAPI)(nil).PutParameterWithContext), varargs...) -} - -// PutResourcePolicy mocks base method. -func (m *MockSSMAPI) PutResourcePolicy(arg0 *ssm.PutResourcePolicyInput) (*ssm.PutResourcePolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutResourcePolicy", arg0) - ret0, _ := ret[0].(*ssm.PutResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutResourcePolicy indicates an expected call of PutResourcePolicy. -func (mr *MockSSMAPIMockRecorder) PutResourcePolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicy", reflect.TypeOf((*MockSSMAPI)(nil).PutResourcePolicy), arg0) -} - -// PutResourcePolicyRequest mocks base method. -func (m *MockSSMAPI) PutResourcePolicyRequest(arg0 *ssm.PutResourcePolicyInput) (*request.Request, *ssm.PutResourcePolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutResourcePolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.PutResourcePolicyOutput) - return ret0, ret1 -} - -// PutResourcePolicyRequest indicates an expected call of PutResourcePolicyRequest. -func (mr *MockSSMAPIMockRecorder) PutResourcePolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicyRequest", reflect.TypeOf((*MockSSMAPI)(nil).PutResourcePolicyRequest), arg0) -} - -// PutResourcePolicyWithContext mocks base method. -func (m *MockSSMAPI) PutResourcePolicyWithContext(arg0 context.Context, arg1 *ssm.PutResourcePolicyInput, arg2 ...request.Option) (*ssm.PutResourcePolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PutResourcePolicyWithContext", varargs...) - ret0, _ := ret[0].(*ssm.PutResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutResourcePolicyWithContext indicates an expected call of PutResourcePolicyWithContext. -func (mr *MockSSMAPIMockRecorder) PutResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicyWithContext", reflect.TypeOf((*MockSSMAPI)(nil).PutResourcePolicyWithContext), varargs...) -} - -// RegisterDefaultPatchBaseline mocks base method. -func (m *MockSSMAPI) RegisterDefaultPatchBaseline(arg0 *ssm.RegisterDefaultPatchBaselineInput) (*ssm.RegisterDefaultPatchBaselineOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterDefaultPatchBaseline", arg0) - ret0, _ := ret[0].(*ssm.RegisterDefaultPatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterDefaultPatchBaseline indicates an expected call of RegisterDefaultPatchBaseline. -func (mr *MockSSMAPIMockRecorder) RegisterDefaultPatchBaseline(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDefaultPatchBaseline", reflect.TypeOf((*MockSSMAPI)(nil).RegisterDefaultPatchBaseline), arg0) -} - -// RegisterDefaultPatchBaselineRequest mocks base method. -func (m *MockSSMAPI) RegisterDefaultPatchBaselineRequest(arg0 *ssm.RegisterDefaultPatchBaselineInput) (*request.Request, *ssm.RegisterDefaultPatchBaselineOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterDefaultPatchBaselineRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.RegisterDefaultPatchBaselineOutput) - return ret0, ret1 -} - -// RegisterDefaultPatchBaselineRequest indicates an expected call of RegisterDefaultPatchBaselineRequest. -func (mr *MockSSMAPIMockRecorder) RegisterDefaultPatchBaselineRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDefaultPatchBaselineRequest", reflect.TypeOf((*MockSSMAPI)(nil).RegisterDefaultPatchBaselineRequest), arg0) -} - -// RegisterDefaultPatchBaselineWithContext mocks base method. -func (m *MockSSMAPI) RegisterDefaultPatchBaselineWithContext(arg0 context.Context, arg1 *ssm.RegisterDefaultPatchBaselineInput, arg2 ...request.Option) (*ssm.RegisterDefaultPatchBaselineOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterDefaultPatchBaselineWithContext", varargs...) - ret0, _ := ret[0].(*ssm.RegisterDefaultPatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterDefaultPatchBaselineWithContext indicates an expected call of RegisterDefaultPatchBaselineWithContext. -func (mr *MockSSMAPIMockRecorder) RegisterDefaultPatchBaselineWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDefaultPatchBaselineWithContext", reflect.TypeOf((*MockSSMAPI)(nil).RegisterDefaultPatchBaselineWithContext), varargs...) -} - -// RegisterPatchBaselineForPatchGroup mocks base method. -func (m *MockSSMAPI) RegisterPatchBaselineForPatchGroup(arg0 *ssm.RegisterPatchBaselineForPatchGroupInput) (*ssm.RegisterPatchBaselineForPatchGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterPatchBaselineForPatchGroup", arg0) - ret0, _ := ret[0].(*ssm.RegisterPatchBaselineForPatchGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterPatchBaselineForPatchGroup indicates an expected call of RegisterPatchBaselineForPatchGroup. -func (mr *MockSSMAPIMockRecorder) RegisterPatchBaselineForPatchGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPatchBaselineForPatchGroup", reflect.TypeOf((*MockSSMAPI)(nil).RegisterPatchBaselineForPatchGroup), arg0) -} - -// RegisterPatchBaselineForPatchGroupRequest mocks base method. -func (m *MockSSMAPI) RegisterPatchBaselineForPatchGroupRequest(arg0 *ssm.RegisterPatchBaselineForPatchGroupInput) (*request.Request, *ssm.RegisterPatchBaselineForPatchGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterPatchBaselineForPatchGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.RegisterPatchBaselineForPatchGroupOutput) - return ret0, ret1 -} - -// RegisterPatchBaselineForPatchGroupRequest indicates an expected call of RegisterPatchBaselineForPatchGroupRequest. -func (mr *MockSSMAPIMockRecorder) RegisterPatchBaselineForPatchGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPatchBaselineForPatchGroupRequest", reflect.TypeOf((*MockSSMAPI)(nil).RegisterPatchBaselineForPatchGroupRequest), arg0) -} - -// RegisterPatchBaselineForPatchGroupWithContext mocks base method. -func (m *MockSSMAPI) RegisterPatchBaselineForPatchGroupWithContext(arg0 context.Context, arg1 *ssm.RegisterPatchBaselineForPatchGroupInput, arg2 ...request.Option) (*ssm.RegisterPatchBaselineForPatchGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterPatchBaselineForPatchGroupWithContext", varargs...) - ret0, _ := ret[0].(*ssm.RegisterPatchBaselineForPatchGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterPatchBaselineForPatchGroupWithContext indicates an expected call of RegisterPatchBaselineForPatchGroupWithContext. -func (mr *MockSSMAPIMockRecorder) RegisterPatchBaselineForPatchGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPatchBaselineForPatchGroupWithContext", reflect.TypeOf((*MockSSMAPI)(nil).RegisterPatchBaselineForPatchGroupWithContext), varargs...) -} - -// RegisterTargetWithMaintenanceWindow mocks base method. -func (m *MockSSMAPI) RegisterTargetWithMaintenanceWindow(arg0 *ssm.RegisterTargetWithMaintenanceWindowInput) (*ssm.RegisterTargetWithMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTargetWithMaintenanceWindow", arg0) - ret0, _ := ret[0].(*ssm.RegisterTargetWithMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTargetWithMaintenanceWindow indicates an expected call of RegisterTargetWithMaintenanceWindow. -func (mr *MockSSMAPIMockRecorder) RegisterTargetWithMaintenanceWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetWithMaintenanceWindow", reflect.TypeOf((*MockSSMAPI)(nil).RegisterTargetWithMaintenanceWindow), arg0) -} - -// RegisterTargetWithMaintenanceWindowRequest mocks base method. -func (m *MockSSMAPI) RegisterTargetWithMaintenanceWindowRequest(arg0 *ssm.RegisterTargetWithMaintenanceWindowInput) (*request.Request, *ssm.RegisterTargetWithMaintenanceWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTargetWithMaintenanceWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.RegisterTargetWithMaintenanceWindowOutput) - return ret0, ret1 -} - -// RegisterTargetWithMaintenanceWindowRequest indicates an expected call of RegisterTargetWithMaintenanceWindowRequest. -func (mr *MockSSMAPIMockRecorder) RegisterTargetWithMaintenanceWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetWithMaintenanceWindowRequest", reflect.TypeOf((*MockSSMAPI)(nil).RegisterTargetWithMaintenanceWindowRequest), arg0) -} - -// RegisterTargetWithMaintenanceWindowWithContext mocks base method. -func (m *MockSSMAPI) RegisterTargetWithMaintenanceWindowWithContext(arg0 context.Context, arg1 *ssm.RegisterTargetWithMaintenanceWindowInput, arg2 ...request.Option) (*ssm.RegisterTargetWithMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterTargetWithMaintenanceWindowWithContext", varargs...) - ret0, _ := ret[0].(*ssm.RegisterTargetWithMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTargetWithMaintenanceWindowWithContext indicates an expected call of RegisterTargetWithMaintenanceWindowWithContext. -func (mr *MockSSMAPIMockRecorder) RegisterTargetWithMaintenanceWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetWithMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).RegisterTargetWithMaintenanceWindowWithContext), varargs...) -} - -// RegisterTaskWithMaintenanceWindow mocks base method. -func (m *MockSSMAPI) RegisterTaskWithMaintenanceWindow(arg0 *ssm.RegisterTaskWithMaintenanceWindowInput) (*ssm.RegisterTaskWithMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTaskWithMaintenanceWindow", arg0) - ret0, _ := ret[0].(*ssm.RegisterTaskWithMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTaskWithMaintenanceWindow indicates an expected call of RegisterTaskWithMaintenanceWindow. -func (mr *MockSSMAPIMockRecorder) RegisterTaskWithMaintenanceWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskWithMaintenanceWindow", reflect.TypeOf((*MockSSMAPI)(nil).RegisterTaskWithMaintenanceWindow), arg0) -} - -// RegisterTaskWithMaintenanceWindowRequest mocks base method. -func (m *MockSSMAPI) RegisterTaskWithMaintenanceWindowRequest(arg0 *ssm.RegisterTaskWithMaintenanceWindowInput) (*request.Request, *ssm.RegisterTaskWithMaintenanceWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTaskWithMaintenanceWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.RegisterTaskWithMaintenanceWindowOutput) - return ret0, ret1 -} - -// RegisterTaskWithMaintenanceWindowRequest indicates an expected call of RegisterTaskWithMaintenanceWindowRequest. -func (mr *MockSSMAPIMockRecorder) RegisterTaskWithMaintenanceWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskWithMaintenanceWindowRequest", reflect.TypeOf((*MockSSMAPI)(nil).RegisterTaskWithMaintenanceWindowRequest), arg0) -} - -// RegisterTaskWithMaintenanceWindowWithContext mocks base method. -func (m *MockSSMAPI) RegisterTaskWithMaintenanceWindowWithContext(arg0 context.Context, arg1 *ssm.RegisterTaskWithMaintenanceWindowInput, arg2 ...request.Option) (*ssm.RegisterTaskWithMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterTaskWithMaintenanceWindowWithContext", varargs...) - ret0, _ := ret[0].(*ssm.RegisterTaskWithMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTaskWithMaintenanceWindowWithContext indicates an expected call of RegisterTaskWithMaintenanceWindowWithContext. -func (mr *MockSSMAPIMockRecorder) RegisterTaskWithMaintenanceWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskWithMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).RegisterTaskWithMaintenanceWindowWithContext), varargs...) -} - -// RemoveTagsFromResource mocks base method. -func (m *MockSSMAPI) RemoveTagsFromResource(arg0 *ssm.RemoveTagsFromResourceInput) (*ssm.RemoveTagsFromResourceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveTagsFromResource", arg0) - ret0, _ := ret[0].(*ssm.RemoveTagsFromResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveTagsFromResource indicates an expected call of RemoveTagsFromResource. -func (mr *MockSSMAPIMockRecorder) RemoveTagsFromResource(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResource", reflect.TypeOf((*MockSSMAPI)(nil).RemoveTagsFromResource), arg0) -} - -// RemoveTagsFromResourceRequest mocks base method. -func (m *MockSSMAPI) RemoveTagsFromResourceRequest(arg0 *ssm.RemoveTagsFromResourceInput) (*request.Request, *ssm.RemoveTagsFromResourceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveTagsFromResourceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.RemoveTagsFromResourceOutput) - return ret0, ret1 -} - -// RemoveTagsFromResourceRequest indicates an expected call of RemoveTagsFromResourceRequest. -func (mr *MockSSMAPIMockRecorder) RemoveTagsFromResourceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResourceRequest", reflect.TypeOf((*MockSSMAPI)(nil).RemoveTagsFromResourceRequest), arg0) -} - -// RemoveTagsFromResourceWithContext mocks base method. -func (m *MockSSMAPI) RemoveTagsFromResourceWithContext(arg0 context.Context, arg1 *ssm.RemoveTagsFromResourceInput, arg2 ...request.Option) (*ssm.RemoveTagsFromResourceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RemoveTagsFromResourceWithContext", varargs...) - ret0, _ := ret[0].(*ssm.RemoveTagsFromResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveTagsFromResourceWithContext indicates an expected call of RemoveTagsFromResourceWithContext. -func (mr *MockSSMAPIMockRecorder) RemoveTagsFromResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResourceWithContext", reflect.TypeOf((*MockSSMAPI)(nil).RemoveTagsFromResourceWithContext), varargs...) -} - -// ResetServiceSetting mocks base method. -func (m *MockSSMAPI) ResetServiceSetting(arg0 *ssm.ResetServiceSettingInput) (*ssm.ResetServiceSettingOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetServiceSetting", arg0) - ret0, _ := ret[0].(*ssm.ResetServiceSettingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetServiceSetting indicates an expected call of ResetServiceSetting. -func (mr *MockSSMAPIMockRecorder) ResetServiceSetting(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetServiceSetting", reflect.TypeOf((*MockSSMAPI)(nil).ResetServiceSetting), arg0) -} - -// ResetServiceSettingRequest mocks base method. -func (m *MockSSMAPI) ResetServiceSettingRequest(arg0 *ssm.ResetServiceSettingInput) (*request.Request, *ssm.ResetServiceSettingOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetServiceSettingRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ResetServiceSettingOutput) - return ret0, ret1 -} - -// ResetServiceSettingRequest indicates an expected call of ResetServiceSettingRequest. -func (mr *MockSSMAPIMockRecorder) ResetServiceSettingRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetServiceSettingRequest", reflect.TypeOf((*MockSSMAPI)(nil).ResetServiceSettingRequest), arg0) -} - -// ResetServiceSettingWithContext mocks base method. -func (m *MockSSMAPI) ResetServiceSettingWithContext(arg0 context.Context, arg1 *ssm.ResetServiceSettingInput, arg2 ...request.Option) (*ssm.ResetServiceSettingOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ResetServiceSettingWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ResetServiceSettingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetServiceSettingWithContext indicates an expected call of ResetServiceSettingWithContext. -func (mr *MockSSMAPIMockRecorder) ResetServiceSettingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetServiceSettingWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ResetServiceSettingWithContext), varargs...) -} - -// ResumeSession mocks base method. -func (m *MockSSMAPI) ResumeSession(arg0 *ssm.ResumeSessionInput) (*ssm.ResumeSessionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResumeSession", arg0) - ret0, _ := ret[0].(*ssm.ResumeSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResumeSession indicates an expected call of ResumeSession. -func (mr *MockSSMAPIMockRecorder) ResumeSession(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeSession", reflect.TypeOf((*MockSSMAPI)(nil).ResumeSession), arg0) -} - -// ResumeSessionRequest mocks base method. -func (m *MockSSMAPI) ResumeSessionRequest(arg0 *ssm.ResumeSessionInput) (*request.Request, *ssm.ResumeSessionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResumeSessionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.ResumeSessionOutput) - return ret0, ret1 -} - -// ResumeSessionRequest indicates an expected call of ResumeSessionRequest. -func (mr *MockSSMAPIMockRecorder) ResumeSessionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeSessionRequest", reflect.TypeOf((*MockSSMAPI)(nil).ResumeSessionRequest), arg0) -} - -// ResumeSessionWithContext mocks base method. -func (m *MockSSMAPI) ResumeSessionWithContext(arg0 context.Context, arg1 *ssm.ResumeSessionInput, arg2 ...request.Option) (*ssm.ResumeSessionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ResumeSessionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.ResumeSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResumeSessionWithContext indicates an expected call of ResumeSessionWithContext. -func (mr *MockSSMAPIMockRecorder) ResumeSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeSessionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).ResumeSessionWithContext), varargs...) -} - -// SendAutomationSignal mocks base method. -func (m *MockSSMAPI) SendAutomationSignal(arg0 *ssm.SendAutomationSignalInput) (*ssm.SendAutomationSignalOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendAutomationSignal", arg0) - ret0, _ := ret[0].(*ssm.SendAutomationSignalOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendAutomationSignal indicates an expected call of SendAutomationSignal. -func (mr *MockSSMAPIMockRecorder) SendAutomationSignal(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAutomationSignal", reflect.TypeOf((*MockSSMAPI)(nil).SendAutomationSignal), arg0) -} - -// SendAutomationSignalRequest mocks base method. -func (m *MockSSMAPI) SendAutomationSignalRequest(arg0 *ssm.SendAutomationSignalInput) (*request.Request, *ssm.SendAutomationSignalOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendAutomationSignalRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.SendAutomationSignalOutput) - return ret0, ret1 -} - -// SendAutomationSignalRequest indicates an expected call of SendAutomationSignalRequest. -func (mr *MockSSMAPIMockRecorder) SendAutomationSignalRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAutomationSignalRequest", reflect.TypeOf((*MockSSMAPI)(nil).SendAutomationSignalRequest), arg0) -} - -// SendAutomationSignalWithContext mocks base method. -func (m *MockSSMAPI) SendAutomationSignalWithContext(arg0 context.Context, arg1 *ssm.SendAutomationSignalInput, arg2 ...request.Option) (*ssm.SendAutomationSignalOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SendAutomationSignalWithContext", varargs...) - ret0, _ := ret[0].(*ssm.SendAutomationSignalOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendAutomationSignalWithContext indicates an expected call of SendAutomationSignalWithContext. -func (mr *MockSSMAPIMockRecorder) SendAutomationSignalWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAutomationSignalWithContext", reflect.TypeOf((*MockSSMAPI)(nil).SendAutomationSignalWithContext), varargs...) -} - -// SendCommand mocks base method. -func (m *MockSSMAPI) SendCommand(arg0 *ssm.SendCommandInput) (*ssm.SendCommandOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendCommand", arg0) - ret0, _ := ret[0].(*ssm.SendCommandOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendCommand indicates an expected call of SendCommand. -func (mr *MockSSMAPIMockRecorder) SendCommand(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCommand", reflect.TypeOf((*MockSSMAPI)(nil).SendCommand), arg0) -} - -// SendCommandRequest mocks base method. -func (m *MockSSMAPI) SendCommandRequest(arg0 *ssm.SendCommandInput) (*request.Request, *ssm.SendCommandOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendCommandRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.SendCommandOutput) - return ret0, ret1 -} - -// SendCommandRequest indicates an expected call of SendCommandRequest. -func (mr *MockSSMAPIMockRecorder) SendCommandRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCommandRequest", reflect.TypeOf((*MockSSMAPI)(nil).SendCommandRequest), arg0) -} - -// SendCommandWithContext mocks base method. -func (m *MockSSMAPI) SendCommandWithContext(arg0 context.Context, arg1 *ssm.SendCommandInput, arg2 ...request.Option) (*ssm.SendCommandOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SendCommandWithContext", varargs...) - ret0, _ := ret[0].(*ssm.SendCommandOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendCommandWithContext indicates an expected call of SendCommandWithContext. -func (mr *MockSSMAPIMockRecorder) SendCommandWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCommandWithContext", reflect.TypeOf((*MockSSMAPI)(nil).SendCommandWithContext), varargs...) -} - -// StartAssociationsOnce mocks base method. -func (m *MockSSMAPI) StartAssociationsOnce(arg0 *ssm.StartAssociationsOnceInput) (*ssm.StartAssociationsOnceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartAssociationsOnce", arg0) - ret0, _ := ret[0].(*ssm.StartAssociationsOnceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartAssociationsOnce indicates an expected call of StartAssociationsOnce. -func (mr *MockSSMAPIMockRecorder) StartAssociationsOnce(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAssociationsOnce", reflect.TypeOf((*MockSSMAPI)(nil).StartAssociationsOnce), arg0) -} - -// StartAssociationsOnceRequest mocks base method. -func (m *MockSSMAPI) StartAssociationsOnceRequest(arg0 *ssm.StartAssociationsOnceInput) (*request.Request, *ssm.StartAssociationsOnceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartAssociationsOnceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.StartAssociationsOnceOutput) - return ret0, ret1 -} - -// StartAssociationsOnceRequest indicates an expected call of StartAssociationsOnceRequest. -func (mr *MockSSMAPIMockRecorder) StartAssociationsOnceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAssociationsOnceRequest", reflect.TypeOf((*MockSSMAPI)(nil).StartAssociationsOnceRequest), arg0) -} - -// StartAssociationsOnceWithContext mocks base method. -func (m *MockSSMAPI) StartAssociationsOnceWithContext(arg0 context.Context, arg1 *ssm.StartAssociationsOnceInput, arg2 ...request.Option) (*ssm.StartAssociationsOnceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StartAssociationsOnceWithContext", varargs...) - ret0, _ := ret[0].(*ssm.StartAssociationsOnceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartAssociationsOnceWithContext indicates an expected call of StartAssociationsOnceWithContext. -func (mr *MockSSMAPIMockRecorder) StartAssociationsOnceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAssociationsOnceWithContext", reflect.TypeOf((*MockSSMAPI)(nil).StartAssociationsOnceWithContext), varargs...) -} - -// StartAutomationExecution mocks base method. -func (m *MockSSMAPI) StartAutomationExecution(arg0 *ssm.StartAutomationExecutionInput) (*ssm.StartAutomationExecutionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartAutomationExecution", arg0) - ret0, _ := ret[0].(*ssm.StartAutomationExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartAutomationExecution indicates an expected call of StartAutomationExecution. -func (mr *MockSSMAPIMockRecorder) StartAutomationExecution(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAutomationExecution", reflect.TypeOf((*MockSSMAPI)(nil).StartAutomationExecution), arg0) -} - -// StartAutomationExecutionRequest mocks base method. -func (m *MockSSMAPI) StartAutomationExecutionRequest(arg0 *ssm.StartAutomationExecutionInput) (*request.Request, *ssm.StartAutomationExecutionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartAutomationExecutionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.StartAutomationExecutionOutput) - return ret0, ret1 -} - -// StartAutomationExecutionRequest indicates an expected call of StartAutomationExecutionRequest. -func (mr *MockSSMAPIMockRecorder) StartAutomationExecutionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAutomationExecutionRequest", reflect.TypeOf((*MockSSMAPI)(nil).StartAutomationExecutionRequest), arg0) -} - -// StartAutomationExecutionWithContext mocks base method. -func (m *MockSSMAPI) StartAutomationExecutionWithContext(arg0 context.Context, arg1 *ssm.StartAutomationExecutionInput, arg2 ...request.Option) (*ssm.StartAutomationExecutionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StartAutomationExecutionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.StartAutomationExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartAutomationExecutionWithContext indicates an expected call of StartAutomationExecutionWithContext. -func (mr *MockSSMAPIMockRecorder) StartAutomationExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAutomationExecutionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).StartAutomationExecutionWithContext), varargs...) -} - -// StartChangeRequestExecution mocks base method. -func (m *MockSSMAPI) StartChangeRequestExecution(arg0 *ssm.StartChangeRequestExecutionInput) (*ssm.StartChangeRequestExecutionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartChangeRequestExecution", arg0) - ret0, _ := ret[0].(*ssm.StartChangeRequestExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartChangeRequestExecution indicates an expected call of StartChangeRequestExecution. -func (mr *MockSSMAPIMockRecorder) StartChangeRequestExecution(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartChangeRequestExecution", reflect.TypeOf((*MockSSMAPI)(nil).StartChangeRequestExecution), arg0) -} - -// StartChangeRequestExecutionRequest mocks base method. -func (m *MockSSMAPI) StartChangeRequestExecutionRequest(arg0 *ssm.StartChangeRequestExecutionInput) (*request.Request, *ssm.StartChangeRequestExecutionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartChangeRequestExecutionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.StartChangeRequestExecutionOutput) - return ret0, ret1 -} - -// StartChangeRequestExecutionRequest indicates an expected call of StartChangeRequestExecutionRequest. -func (mr *MockSSMAPIMockRecorder) StartChangeRequestExecutionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartChangeRequestExecutionRequest", reflect.TypeOf((*MockSSMAPI)(nil).StartChangeRequestExecutionRequest), arg0) -} - -// StartChangeRequestExecutionWithContext mocks base method. -func (m *MockSSMAPI) StartChangeRequestExecutionWithContext(arg0 context.Context, arg1 *ssm.StartChangeRequestExecutionInput, arg2 ...request.Option) (*ssm.StartChangeRequestExecutionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StartChangeRequestExecutionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.StartChangeRequestExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartChangeRequestExecutionWithContext indicates an expected call of StartChangeRequestExecutionWithContext. -func (mr *MockSSMAPIMockRecorder) StartChangeRequestExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartChangeRequestExecutionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).StartChangeRequestExecutionWithContext), varargs...) -} - -// StartSession mocks base method. -func (m *MockSSMAPI) StartSession(arg0 *ssm.StartSessionInput) (*ssm.StartSessionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartSession", arg0) - ret0, _ := ret[0].(*ssm.StartSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartSession indicates an expected call of StartSession. -func (mr *MockSSMAPIMockRecorder) StartSession(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartSession", reflect.TypeOf((*MockSSMAPI)(nil).StartSession), arg0) -} - -// StartSessionRequest mocks base method. -func (m *MockSSMAPI) StartSessionRequest(arg0 *ssm.StartSessionInput) (*request.Request, *ssm.StartSessionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartSessionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.StartSessionOutput) - return ret0, ret1 -} - -// StartSessionRequest indicates an expected call of StartSessionRequest. -func (mr *MockSSMAPIMockRecorder) StartSessionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartSessionRequest", reflect.TypeOf((*MockSSMAPI)(nil).StartSessionRequest), arg0) -} - -// StartSessionWithContext mocks base method. -func (m *MockSSMAPI) StartSessionWithContext(arg0 context.Context, arg1 *ssm.StartSessionInput, arg2 ...request.Option) (*ssm.StartSessionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StartSessionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.StartSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartSessionWithContext indicates an expected call of StartSessionWithContext. -func (mr *MockSSMAPIMockRecorder) StartSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartSessionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).StartSessionWithContext), varargs...) -} - -// StopAutomationExecution mocks base method. -func (m *MockSSMAPI) StopAutomationExecution(arg0 *ssm.StopAutomationExecutionInput) (*ssm.StopAutomationExecutionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StopAutomationExecution", arg0) - ret0, _ := ret[0].(*ssm.StopAutomationExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StopAutomationExecution indicates an expected call of StopAutomationExecution. -func (mr *MockSSMAPIMockRecorder) StopAutomationExecution(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAutomationExecution", reflect.TypeOf((*MockSSMAPI)(nil).StopAutomationExecution), arg0) -} - -// StopAutomationExecutionRequest mocks base method. -func (m *MockSSMAPI) StopAutomationExecutionRequest(arg0 *ssm.StopAutomationExecutionInput) (*request.Request, *ssm.StopAutomationExecutionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StopAutomationExecutionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.StopAutomationExecutionOutput) - return ret0, ret1 -} - -// StopAutomationExecutionRequest indicates an expected call of StopAutomationExecutionRequest. -func (mr *MockSSMAPIMockRecorder) StopAutomationExecutionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAutomationExecutionRequest", reflect.TypeOf((*MockSSMAPI)(nil).StopAutomationExecutionRequest), arg0) -} - -// StopAutomationExecutionWithContext mocks base method. -func (m *MockSSMAPI) StopAutomationExecutionWithContext(arg0 context.Context, arg1 *ssm.StopAutomationExecutionInput, arg2 ...request.Option) (*ssm.StopAutomationExecutionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StopAutomationExecutionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.StopAutomationExecutionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StopAutomationExecutionWithContext indicates an expected call of StopAutomationExecutionWithContext. -func (mr *MockSSMAPIMockRecorder) StopAutomationExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAutomationExecutionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).StopAutomationExecutionWithContext), varargs...) -} - -// TerminateSession mocks base method. -func (m *MockSSMAPI) TerminateSession(arg0 *ssm.TerminateSessionInput) (*ssm.TerminateSessionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TerminateSession", arg0) - ret0, _ := ret[0].(*ssm.TerminateSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TerminateSession indicates an expected call of TerminateSession. -func (mr *MockSSMAPIMockRecorder) TerminateSession(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateSession", reflect.TypeOf((*MockSSMAPI)(nil).TerminateSession), arg0) -} - -// TerminateSessionRequest mocks base method. -func (m *MockSSMAPI) TerminateSessionRequest(arg0 *ssm.TerminateSessionInput) (*request.Request, *ssm.TerminateSessionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TerminateSessionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.TerminateSessionOutput) - return ret0, ret1 -} - -// TerminateSessionRequest indicates an expected call of TerminateSessionRequest. -func (mr *MockSSMAPIMockRecorder) TerminateSessionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateSessionRequest", reflect.TypeOf((*MockSSMAPI)(nil).TerminateSessionRequest), arg0) -} - -// TerminateSessionWithContext mocks base method. -func (m *MockSSMAPI) TerminateSessionWithContext(arg0 context.Context, arg1 *ssm.TerminateSessionInput, arg2 ...request.Option) (*ssm.TerminateSessionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "TerminateSessionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.TerminateSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TerminateSessionWithContext indicates an expected call of TerminateSessionWithContext. -func (mr *MockSSMAPIMockRecorder) TerminateSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateSessionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).TerminateSessionWithContext), varargs...) -} - -// UnlabelParameterVersion mocks base method. -func (m *MockSSMAPI) UnlabelParameterVersion(arg0 *ssm.UnlabelParameterVersionInput) (*ssm.UnlabelParameterVersionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnlabelParameterVersion", arg0) - ret0, _ := ret[0].(*ssm.UnlabelParameterVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnlabelParameterVersion indicates an expected call of UnlabelParameterVersion. -func (mr *MockSSMAPIMockRecorder) UnlabelParameterVersion(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlabelParameterVersion", reflect.TypeOf((*MockSSMAPI)(nil).UnlabelParameterVersion), arg0) -} - -// UnlabelParameterVersionRequest mocks base method. -func (m *MockSSMAPI) UnlabelParameterVersionRequest(arg0 *ssm.UnlabelParameterVersionInput) (*request.Request, *ssm.UnlabelParameterVersionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnlabelParameterVersionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UnlabelParameterVersionOutput) - return ret0, ret1 -} - -// UnlabelParameterVersionRequest indicates an expected call of UnlabelParameterVersionRequest. -func (mr *MockSSMAPIMockRecorder) UnlabelParameterVersionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlabelParameterVersionRequest", reflect.TypeOf((*MockSSMAPI)(nil).UnlabelParameterVersionRequest), arg0) -} - -// UnlabelParameterVersionWithContext mocks base method. -func (m *MockSSMAPI) UnlabelParameterVersionWithContext(arg0 context.Context, arg1 *ssm.UnlabelParameterVersionInput, arg2 ...request.Option) (*ssm.UnlabelParameterVersionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UnlabelParameterVersionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UnlabelParameterVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnlabelParameterVersionWithContext indicates an expected call of UnlabelParameterVersionWithContext. -func (mr *MockSSMAPIMockRecorder) UnlabelParameterVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlabelParameterVersionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UnlabelParameterVersionWithContext), varargs...) -} - -// UpdateAssociation mocks base method. -func (m *MockSSMAPI) UpdateAssociation(arg0 *ssm.UpdateAssociationInput) (*ssm.UpdateAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateAssociation", arg0) - ret0, _ := ret[0].(*ssm.UpdateAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateAssociation indicates an expected call of UpdateAssociation. -func (mr *MockSSMAPIMockRecorder) UpdateAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssociation", reflect.TypeOf((*MockSSMAPI)(nil).UpdateAssociation), arg0) -} - -// UpdateAssociationRequest mocks base method. -func (m *MockSSMAPI) UpdateAssociationRequest(arg0 *ssm.UpdateAssociationInput) (*request.Request, *ssm.UpdateAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateAssociationOutput) - return ret0, ret1 -} - -// UpdateAssociationRequest indicates an expected call of UpdateAssociationRequest. -func (mr *MockSSMAPIMockRecorder) UpdateAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssociationRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateAssociationRequest), arg0) -} - -// UpdateAssociationStatus mocks base method. -func (m *MockSSMAPI) UpdateAssociationStatus(arg0 *ssm.UpdateAssociationStatusInput) (*ssm.UpdateAssociationStatusOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateAssociationStatus", arg0) - ret0, _ := ret[0].(*ssm.UpdateAssociationStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateAssociationStatus indicates an expected call of UpdateAssociationStatus. -func (mr *MockSSMAPIMockRecorder) UpdateAssociationStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssociationStatus", reflect.TypeOf((*MockSSMAPI)(nil).UpdateAssociationStatus), arg0) -} - -// UpdateAssociationStatusRequest mocks base method. -func (m *MockSSMAPI) UpdateAssociationStatusRequest(arg0 *ssm.UpdateAssociationStatusInput) (*request.Request, *ssm.UpdateAssociationStatusOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateAssociationStatusRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateAssociationStatusOutput) - return ret0, ret1 -} - -// UpdateAssociationStatusRequest indicates an expected call of UpdateAssociationStatusRequest. -func (mr *MockSSMAPIMockRecorder) UpdateAssociationStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssociationStatusRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateAssociationStatusRequest), arg0) -} - -// UpdateAssociationStatusWithContext mocks base method. -func (m *MockSSMAPI) UpdateAssociationStatusWithContext(arg0 context.Context, arg1 *ssm.UpdateAssociationStatusInput, arg2 ...request.Option) (*ssm.UpdateAssociationStatusOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateAssociationStatusWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateAssociationStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateAssociationStatusWithContext indicates an expected call of UpdateAssociationStatusWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateAssociationStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssociationStatusWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateAssociationStatusWithContext), varargs...) -} - -// UpdateAssociationWithContext mocks base method. -func (m *MockSSMAPI) UpdateAssociationWithContext(arg0 context.Context, arg1 *ssm.UpdateAssociationInput, arg2 ...request.Option) (*ssm.UpdateAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateAssociationWithContext indicates an expected call of UpdateAssociationWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssociationWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateAssociationWithContext), varargs...) -} - -// UpdateDocument mocks base method. -func (m *MockSSMAPI) UpdateDocument(arg0 *ssm.UpdateDocumentInput) (*ssm.UpdateDocumentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateDocument", arg0) - ret0, _ := ret[0].(*ssm.UpdateDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateDocument indicates an expected call of UpdateDocument. -func (mr *MockSSMAPIMockRecorder) UpdateDocument(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocument", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocument), arg0) -} - -// UpdateDocumentDefaultVersion mocks base method. -func (m *MockSSMAPI) UpdateDocumentDefaultVersion(arg0 *ssm.UpdateDocumentDefaultVersionInput) (*ssm.UpdateDocumentDefaultVersionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateDocumentDefaultVersion", arg0) - ret0, _ := ret[0].(*ssm.UpdateDocumentDefaultVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateDocumentDefaultVersion indicates an expected call of UpdateDocumentDefaultVersion. -func (mr *MockSSMAPIMockRecorder) UpdateDocumentDefaultVersion(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocumentDefaultVersion", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocumentDefaultVersion), arg0) -} - -// UpdateDocumentDefaultVersionRequest mocks base method. -func (m *MockSSMAPI) UpdateDocumentDefaultVersionRequest(arg0 *ssm.UpdateDocumentDefaultVersionInput) (*request.Request, *ssm.UpdateDocumentDefaultVersionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateDocumentDefaultVersionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateDocumentDefaultVersionOutput) - return ret0, ret1 -} - -// UpdateDocumentDefaultVersionRequest indicates an expected call of UpdateDocumentDefaultVersionRequest. -func (mr *MockSSMAPIMockRecorder) UpdateDocumentDefaultVersionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocumentDefaultVersionRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocumentDefaultVersionRequest), arg0) -} - -// UpdateDocumentDefaultVersionWithContext mocks base method. -func (m *MockSSMAPI) UpdateDocumentDefaultVersionWithContext(arg0 context.Context, arg1 *ssm.UpdateDocumentDefaultVersionInput, arg2 ...request.Option) (*ssm.UpdateDocumentDefaultVersionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateDocumentDefaultVersionWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateDocumentDefaultVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateDocumentDefaultVersionWithContext indicates an expected call of UpdateDocumentDefaultVersionWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateDocumentDefaultVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocumentDefaultVersionWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocumentDefaultVersionWithContext), varargs...) -} - -// UpdateDocumentMetadata mocks base method. -func (m *MockSSMAPI) UpdateDocumentMetadata(arg0 *ssm.UpdateDocumentMetadataInput) (*ssm.UpdateDocumentMetadataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateDocumentMetadata", arg0) - ret0, _ := ret[0].(*ssm.UpdateDocumentMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateDocumentMetadata indicates an expected call of UpdateDocumentMetadata. -func (mr *MockSSMAPIMockRecorder) UpdateDocumentMetadata(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocumentMetadata", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocumentMetadata), arg0) -} - -// UpdateDocumentMetadataRequest mocks base method. -func (m *MockSSMAPI) UpdateDocumentMetadataRequest(arg0 *ssm.UpdateDocumentMetadataInput) (*request.Request, *ssm.UpdateDocumentMetadataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateDocumentMetadataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateDocumentMetadataOutput) - return ret0, ret1 -} - -// UpdateDocumentMetadataRequest indicates an expected call of UpdateDocumentMetadataRequest. -func (mr *MockSSMAPIMockRecorder) UpdateDocumentMetadataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocumentMetadataRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocumentMetadataRequest), arg0) -} - -// UpdateDocumentMetadataWithContext mocks base method. -func (m *MockSSMAPI) UpdateDocumentMetadataWithContext(arg0 context.Context, arg1 *ssm.UpdateDocumentMetadataInput, arg2 ...request.Option) (*ssm.UpdateDocumentMetadataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateDocumentMetadataWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateDocumentMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateDocumentMetadataWithContext indicates an expected call of UpdateDocumentMetadataWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateDocumentMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocumentMetadataWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocumentMetadataWithContext), varargs...) -} - -// UpdateDocumentRequest mocks base method. -func (m *MockSSMAPI) UpdateDocumentRequest(arg0 *ssm.UpdateDocumentInput) (*request.Request, *ssm.UpdateDocumentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateDocumentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateDocumentOutput) - return ret0, ret1 -} - -// UpdateDocumentRequest indicates an expected call of UpdateDocumentRequest. -func (mr *MockSSMAPIMockRecorder) UpdateDocumentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocumentRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocumentRequest), arg0) -} - -// UpdateDocumentWithContext mocks base method. -func (m *MockSSMAPI) UpdateDocumentWithContext(arg0 context.Context, arg1 *ssm.UpdateDocumentInput, arg2 ...request.Option) (*ssm.UpdateDocumentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateDocumentWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateDocumentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateDocumentWithContext indicates an expected call of UpdateDocumentWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateDocumentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocumentWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateDocumentWithContext), varargs...) -} - -// UpdateMaintenanceWindow mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindow(arg0 *ssm.UpdateMaintenanceWindowInput) (*ssm.UpdateMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateMaintenanceWindow", arg0) - ret0, _ := ret[0].(*ssm.UpdateMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateMaintenanceWindow indicates an expected call of UpdateMaintenanceWindow. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindow", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindow), arg0) -} - -// UpdateMaintenanceWindowRequest mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindowRequest(arg0 *ssm.UpdateMaintenanceWindowInput) (*request.Request, *ssm.UpdateMaintenanceWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateMaintenanceWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateMaintenanceWindowOutput) - return ret0, ret1 -} - -// UpdateMaintenanceWindowRequest indicates an expected call of UpdateMaintenanceWindowRequest. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindowRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindowRequest), arg0) -} - -// UpdateMaintenanceWindowTarget mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindowTarget(arg0 *ssm.UpdateMaintenanceWindowTargetInput) (*ssm.UpdateMaintenanceWindowTargetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateMaintenanceWindowTarget", arg0) - ret0, _ := ret[0].(*ssm.UpdateMaintenanceWindowTargetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateMaintenanceWindowTarget indicates an expected call of UpdateMaintenanceWindowTarget. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindowTarget(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindowTarget", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindowTarget), arg0) -} - -// UpdateMaintenanceWindowTargetRequest mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindowTargetRequest(arg0 *ssm.UpdateMaintenanceWindowTargetInput) (*request.Request, *ssm.UpdateMaintenanceWindowTargetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateMaintenanceWindowTargetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateMaintenanceWindowTargetOutput) - return ret0, ret1 -} - -// UpdateMaintenanceWindowTargetRequest indicates an expected call of UpdateMaintenanceWindowTargetRequest. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindowTargetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindowTargetRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindowTargetRequest), arg0) -} - -// UpdateMaintenanceWindowTargetWithContext mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindowTargetWithContext(arg0 context.Context, arg1 *ssm.UpdateMaintenanceWindowTargetInput, arg2 ...request.Option) (*ssm.UpdateMaintenanceWindowTargetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateMaintenanceWindowTargetWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateMaintenanceWindowTargetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateMaintenanceWindowTargetWithContext indicates an expected call of UpdateMaintenanceWindowTargetWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindowTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindowTargetWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindowTargetWithContext), varargs...) -} - -// UpdateMaintenanceWindowTask mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindowTask(arg0 *ssm.UpdateMaintenanceWindowTaskInput) (*ssm.UpdateMaintenanceWindowTaskOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateMaintenanceWindowTask", arg0) - ret0, _ := ret[0].(*ssm.UpdateMaintenanceWindowTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateMaintenanceWindowTask indicates an expected call of UpdateMaintenanceWindowTask. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindowTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindowTask", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindowTask), arg0) -} - -// UpdateMaintenanceWindowTaskRequest mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindowTaskRequest(arg0 *ssm.UpdateMaintenanceWindowTaskInput) (*request.Request, *ssm.UpdateMaintenanceWindowTaskOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateMaintenanceWindowTaskRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateMaintenanceWindowTaskOutput) - return ret0, ret1 -} - -// UpdateMaintenanceWindowTaskRequest indicates an expected call of UpdateMaintenanceWindowTaskRequest. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindowTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindowTaskRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindowTaskRequest), arg0) -} - -// UpdateMaintenanceWindowTaskWithContext mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindowTaskWithContext(arg0 context.Context, arg1 *ssm.UpdateMaintenanceWindowTaskInput, arg2 ...request.Option) (*ssm.UpdateMaintenanceWindowTaskOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateMaintenanceWindowTaskWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateMaintenanceWindowTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateMaintenanceWindowTaskWithContext indicates an expected call of UpdateMaintenanceWindowTaskWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindowTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindowTaskWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindowTaskWithContext), varargs...) -} - -// UpdateMaintenanceWindowWithContext mocks base method. -func (m *MockSSMAPI) UpdateMaintenanceWindowWithContext(arg0 context.Context, arg1 *ssm.UpdateMaintenanceWindowInput, arg2 ...request.Option) (*ssm.UpdateMaintenanceWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateMaintenanceWindowWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateMaintenanceWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateMaintenanceWindowWithContext indicates an expected call of UpdateMaintenanceWindowWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateMaintenanceWindowWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateMaintenanceWindowWithContext), varargs...) -} - -// UpdateManagedInstanceRole mocks base method. -func (m *MockSSMAPI) UpdateManagedInstanceRole(arg0 *ssm.UpdateManagedInstanceRoleInput) (*ssm.UpdateManagedInstanceRoleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateManagedInstanceRole", arg0) - ret0, _ := ret[0].(*ssm.UpdateManagedInstanceRoleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateManagedInstanceRole indicates an expected call of UpdateManagedInstanceRole. -func (mr *MockSSMAPIMockRecorder) UpdateManagedInstanceRole(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateManagedInstanceRole", reflect.TypeOf((*MockSSMAPI)(nil).UpdateManagedInstanceRole), arg0) -} - -// UpdateManagedInstanceRoleRequest mocks base method. -func (m *MockSSMAPI) UpdateManagedInstanceRoleRequest(arg0 *ssm.UpdateManagedInstanceRoleInput) (*request.Request, *ssm.UpdateManagedInstanceRoleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateManagedInstanceRoleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateManagedInstanceRoleOutput) - return ret0, ret1 -} - -// UpdateManagedInstanceRoleRequest indicates an expected call of UpdateManagedInstanceRoleRequest. -func (mr *MockSSMAPIMockRecorder) UpdateManagedInstanceRoleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateManagedInstanceRoleRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateManagedInstanceRoleRequest), arg0) -} - -// UpdateManagedInstanceRoleWithContext mocks base method. -func (m *MockSSMAPI) UpdateManagedInstanceRoleWithContext(arg0 context.Context, arg1 *ssm.UpdateManagedInstanceRoleInput, arg2 ...request.Option) (*ssm.UpdateManagedInstanceRoleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateManagedInstanceRoleWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateManagedInstanceRoleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateManagedInstanceRoleWithContext indicates an expected call of UpdateManagedInstanceRoleWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateManagedInstanceRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateManagedInstanceRoleWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateManagedInstanceRoleWithContext), varargs...) -} - -// UpdateOpsItem mocks base method. -func (m *MockSSMAPI) UpdateOpsItem(arg0 *ssm.UpdateOpsItemInput) (*ssm.UpdateOpsItemOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateOpsItem", arg0) - ret0, _ := ret[0].(*ssm.UpdateOpsItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateOpsItem indicates an expected call of UpdateOpsItem. -func (mr *MockSSMAPIMockRecorder) UpdateOpsItem(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpsItem", reflect.TypeOf((*MockSSMAPI)(nil).UpdateOpsItem), arg0) -} - -// UpdateOpsItemRequest mocks base method. -func (m *MockSSMAPI) UpdateOpsItemRequest(arg0 *ssm.UpdateOpsItemInput) (*request.Request, *ssm.UpdateOpsItemOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateOpsItemRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateOpsItemOutput) - return ret0, ret1 -} - -// UpdateOpsItemRequest indicates an expected call of UpdateOpsItemRequest. -func (mr *MockSSMAPIMockRecorder) UpdateOpsItemRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpsItemRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateOpsItemRequest), arg0) -} - -// UpdateOpsItemWithContext mocks base method. -func (m *MockSSMAPI) UpdateOpsItemWithContext(arg0 context.Context, arg1 *ssm.UpdateOpsItemInput, arg2 ...request.Option) (*ssm.UpdateOpsItemOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateOpsItemWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateOpsItemOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateOpsItemWithContext indicates an expected call of UpdateOpsItemWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateOpsItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpsItemWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateOpsItemWithContext), varargs...) -} - -// UpdateOpsMetadata mocks base method. -func (m *MockSSMAPI) UpdateOpsMetadata(arg0 *ssm.UpdateOpsMetadataInput) (*ssm.UpdateOpsMetadataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateOpsMetadata", arg0) - ret0, _ := ret[0].(*ssm.UpdateOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateOpsMetadata indicates an expected call of UpdateOpsMetadata. -func (mr *MockSSMAPIMockRecorder) UpdateOpsMetadata(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpsMetadata", reflect.TypeOf((*MockSSMAPI)(nil).UpdateOpsMetadata), arg0) -} - -// UpdateOpsMetadataRequest mocks base method. -func (m *MockSSMAPI) UpdateOpsMetadataRequest(arg0 *ssm.UpdateOpsMetadataInput) (*request.Request, *ssm.UpdateOpsMetadataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateOpsMetadataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateOpsMetadataOutput) - return ret0, ret1 -} - -// UpdateOpsMetadataRequest indicates an expected call of UpdateOpsMetadataRequest. -func (mr *MockSSMAPIMockRecorder) UpdateOpsMetadataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpsMetadataRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateOpsMetadataRequest), arg0) -} - -// UpdateOpsMetadataWithContext mocks base method. -func (m *MockSSMAPI) UpdateOpsMetadataWithContext(arg0 context.Context, arg1 *ssm.UpdateOpsMetadataInput, arg2 ...request.Option) (*ssm.UpdateOpsMetadataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateOpsMetadataWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateOpsMetadataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateOpsMetadataWithContext indicates an expected call of UpdateOpsMetadataWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateOpsMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpsMetadataWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateOpsMetadataWithContext), varargs...) -} - -// UpdatePatchBaseline mocks base method. -func (m *MockSSMAPI) UpdatePatchBaseline(arg0 *ssm.UpdatePatchBaselineInput) (*ssm.UpdatePatchBaselineOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdatePatchBaseline", arg0) - ret0, _ := ret[0].(*ssm.UpdatePatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdatePatchBaseline indicates an expected call of UpdatePatchBaseline. -func (mr *MockSSMAPIMockRecorder) UpdatePatchBaseline(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePatchBaseline", reflect.TypeOf((*MockSSMAPI)(nil).UpdatePatchBaseline), arg0) -} - -// UpdatePatchBaselineRequest mocks base method. -func (m *MockSSMAPI) UpdatePatchBaselineRequest(arg0 *ssm.UpdatePatchBaselineInput) (*request.Request, *ssm.UpdatePatchBaselineOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdatePatchBaselineRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdatePatchBaselineOutput) - return ret0, ret1 -} - -// UpdatePatchBaselineRequest indicates an expected call of UpdatePatchBaselineRequest. -func (mr *MockSSMAPIMockRecorder) UpdatePatchBaselineRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePatchBaselineRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdatePatchBaselineRequest), arg0) -} - -// UpdatePatchBaselineWithContext mocks base method. -func (m *MockSSMAPI) UpdatePatchBaselineWithContext(arg0 context.Context, arg1 *ssm.UpdatePatchBaselineInput, arg2 ...request.Option) (*ssm.UpdatePatchBaselineOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdatePatchBaselineWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdatePatchBaselineOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdatePatchBaselineWithContext indicates an expected call of UpdatePatchBaselineWithContext. -func (mr *MockSSMAPIMockRecorder) UpdatePatchBaselineWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePatchBaselineWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdatePatchBaselineWithContext), varargs...) -} - -// UpdateResourceDataSync mocks base method. -func (m *MockSSMAPI) UpdateResourceDataSync(arg0 *ssm.UpdateResourceDataSyncInput) (*ssm.UpdateResourceDataSyncOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateResourceDataSync", arg0) - ret0, _ := ret[0].(*ssm.UpdateResourceDataSyncOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateResourceDataSync indicates an expected call of UpdateResourceDataSync. -func (mr *MockSSMAPIMockRecorder) UpdateResourceDataSync(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResourceDataSync", reflect.TypeOf((*MockSSMAPI)(nil).UpdateResourceDataSync), arg0) -} - -// UpdateResourceDataSyncRequest mocks base method. -func (m *MockSSMAPI) UpdateResourceDataSyncRequest(arg0 *ssm.UpdateResourceDataSyncInput) (*request.Request, *ssm.UpdateResourceDataSyncOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateResourceDataSyncRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateResourceDataSyncOutput) - return ret0, ret1 -} - -// UpdateResourceDataSyncRequest indicates an expected call of UpdateResourceDataSyncRequest. -func (mr *MockSSMAPIMockRecorder) UpdateResourceDataSyncRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResourceDataSyncRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateResourceDataSyncRequest), arg0) -} - -// UpdateResourceDataSyncWithContext mocks base method. -func (m *MockSSMAPI) UpdateResourceDataSyncWithContext(arg0 context.Context, arg1 *ssm.UpdateResourceDataSyncInput, arg2 ...request.Option) (*ssm.UpdateResourceDataSyncOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateResourceDataSyncWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateResourceDataSyncOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateResourceDataSyncWithContext indicates an expected call of UpdateResourceDataSyncWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateResourceDataSyncWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResourceDataSyncWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateResourceDataSyncWithContext), varargs...) -} - -// UpdateServiceSetting mocks base method. -func (m *MockSSMAPI) UpdateServiceSetting(arg0 *ssm.UpdateServiceSettingInput) (*ssm.UpdateServiceSettingOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateServiceSetting", arg0) - ret0, _ := ret[0].(*ssm.UpdateServiceSettingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateServiceSetting indicates an expected call of UpdateServiceSetting. -func (mr *MockSSMAPIMockRecorder) UpdateServiceSetting(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceSetting", reflect.TypeOf((*MockSSMAPI)(nil).UpdateServiceSetting), arg0) -} - -// UpdateServiceSettingRequest mocks base method. -func (m *MockSSMAPI) UpdateServiceSettingRequest(arg0 *ssm.UpdateServiceSettingInput) (*request.Request, *ssm.UpdateServiceSettingOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateServiceSettingRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ssm.UpdateServiceSettingOutput) - return ret0, ret1 -} - -// UpdateServiceSettingRequest indicates an expected call of UpdateServiceSettingRequest. -func (mr *MockSSMAPIMockRecorder) UpdateServiceSettingRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceSettingRequest", reflect.TypeOf((*MockSSMAPI)(nil).UpdateServiceSettingRequest), arg0) -} - -// UpdateServiceSettingWithContext mocks base method. -func (m *MockSSMAPI) UpdateServiceSettingWithContext(arg0 context.Context, arg1 *ssm.UpdateServiceSettingInput, arg2 ...request.Option) (*ssm.UpdateServiceSettingOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateServiceSettingWithContext", varargs...) - ret0, _ := ret[0].(*ssm.UpdateServiceSettingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateServiceSettingWithContext indicates an expected call of UpdateServiceSettingWithContext. -func (mr *MockSSMAPIMockRecorder) UpdateServiceSettingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceSettingWithContext", reflect.TypeOf((*MockSSMAPI)(nil).UpdateServiceSettingWithContext), varargs...) -} - -// WaitUntilCommandExecuted mocks base method. -func (m *MockSSMAPI) WaitUntilCommandExecuted(arg0 *ssm.GetCommandInvocationInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilCommandExecuted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilCommandExecuted indicates an expected call of WaitUntilCommandExecuted. -func (mr *MockSSMAPIMockRecorder) WaitUntilCommandExecuted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCommandExecuted", reflect.TypeOf((*MockSSMAPI)(nil).WaitUntilCommandExecuted), arg0) -} - -// WaitUntilCommandExecutedWithContext mocks base method. -func (m *MockSSMAPI) WaitUntilCommandExecutedWithContext(arg0 context.Context, arg1 *ssm.GetCommandInvocationInput, arg2 ...request.WaiterOption) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "WaitUntilCommandExecutedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilCommandExecutedWithContext indicates an expected call of WaitUntilCommandExecutedWithContext. -func (mr *MockSSMAPIMockRecorder) WaitUntilCommandExecutedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCommandExecutedWithContext", reflect.TypeOf((*MockSSMAPI)(nil).WaitUntilCommandExecutedWithContext), varargs...) -} diff --git a/pkg/cloud/services/ssm/secret.go b/pkg/cloud/services/ssm/secret.go index f8bcfc48d0..8d7b269957 100644 --- a/pkg/cloud/services/ssm/secret.go +++ b/pkg/cloud/services/ssm/secret.go @@ -17,12 +17,16 @@ limitations under the License. package ssm import ( + "context" + "errors" "fmt" "path" "regexp" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/ssm" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/ssm" + "github.com/aws/aws-sdk-go-v2/service/ssm/types" + "github.com/aws/smithy-go" kerrors "k8s.io/apimachinery/pkg/util/errors" "k8s.io/apimachinery/pkg/util/uuid" @@ -44,10 +48,30 @@ const ( var ( prefixRe = regexp.MustCompile(`(?i)^[\/]?(aws|ssm)[.]?`) retryableErrors = []string{ - ssm.ErrCodeParameterLimitExceeded, + "ParameterLimitExceeded", + "ParameterAlreadyExists", } ) +func isErrorRetryable(err error, retryableCodes []string) bool { + // Use the ParseSmithyError utility to parse the error + smithyErr := awserrors.ParseSmithyError(err) + if smithyErr == nil { + return false + } + + // Get the error code from the parsed error + codeToCheck := smithyErr.ErrorCode() + + // Compare the extracted string with your list + for _, code := range retryableCodes { + if codeToCheck == code { + return true // It's a match! + } + } + return false +} + // Create stores data in AWS SSM for a given machine, chunking at 4kb per secret. The prefix of the secret // ARN and the number of chunks are returned. func (s *Service) Create(m *scope.MachineScope, data []byte) (string, int32, error) { @@ -93,11 +117,11 @@ func (s *Service) Create(m *scope.MachineScope, data []byte) (string, int32, err // retryableCreateSecret is a function to be passed into a waiter. In a separate function for ease of reading. func (s *Service) retryableCreateSecret(name string, chunk []byte, tags infrav1.Tags) (bool, error) { - _, err := s.SSMClient.PutParameter(&ssm.PutParameterInput{ + _, err := s.SSMClient.PutParameter(context.TODO(), &ssm.PutParameterInput{ Name: aws.String(name), Value: aws.String(string(chunk)), Tags: converters.MapToSSMTags(tags), - Type: aws.String("SecureString"), + Type: types.ParameterTypeSecureString, }) if err != nil { return false, err @@ -107,11 +131,14 @@ func (s *Service) retryableCreateSecret(name string, chunk []byte, tags infrav1. // forceDeleteSecretEntry deletes a single secret, ignoring if it is absent. func (s *Service) forceDeleteSecretEntry(name string) error { - _, err := s.SSMClient.DeleteParameter(&ssm.DeleteParameterInput{ + _, err := s.SSMClient.DeleteParameter(context.TODO(), &ssm.DeleteParameterInput{ Name: aws.String(name), }) - if awserrors.IsNotFound(err) { - return nil + if err != nil { + var aerr smithy.APIError + if errors.As(err, &aerr) && aerr.ErrorCode() == "ParameterNotFound" { + return nil + } } return err } diff --git a/pkg/cloud/services/ssm/secret_test.go b/pkg/cloud/services/ssm/secret_test.go index 04afa9e1d4..5393659304 100644 --- a/pkg/cloud/services/ssm/secret_test.go +++ b/pkg/cloud/services/ssm/secret_test.go @@ -17,13 +17,16 @@ limitations under the License. package ssm import ( + "context" "crypto/rand" "sort" "strings" "testing" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/ssm" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/ssm" + "github.com/aws/aws-sdk-go-v2/service/ssm/types" + "github.com/aws/smithy-go" "github.com/golang/mock/gomock" "github.com/google/go-cmp/cmp" . "github.com/onsi/gomega" @@ -39,6 +42,34 @@ import ( clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1" ) +type mockAPIError struct { + Code string + Message string +} + +// ErrorCode returns the error's code, making it satisfy one part of the interface. +func (e *mockAPIError) ErrorCode() string { + return e.Code +} + +// Error returns the error's message, satisfying the standard 'error' interface. +func (e *mockAPIError) Error() string { + return e.Message +} + +// Error returns the error's message, satisfying the standard 'error' interface. +func (e *mockAPIError) ErrorMessage() string { + return e.Message +} + +// ErrorFault is the missing method needed to fully implement smithy.APIError. +func (e *mockAPIError) ErrorFault() smithy.ErrorFault { + // smithy.FaultClient is a good default for most simulated errors. + return smithy.FaultClient +} + +var _ smithy.APIError = (*mockAPIError)(nil) + func TestServiceCreate(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() @@ -56,18 +87,18 @@ func TestServiceCreate(t *testing.T) { if !strings.HasPrefix(actualPrefix, expectedPrefix) { t.Fatalf("Prefix is not as expected: %v", actualPrefix) } - if (err != nil) != IsErrorExpected { + if (err != nil) != isErrorRetryable(err, retryableErrors) { t.Fatalf("Unexpected error value, error = %v, expectedError %v", err, IsErrorExpected) } } - sortTagsByKey := func(tags []*ssm.Tag) { + sortTagsByKey := func(tags []types.Tag) { sort.Slice(tags, func(i, j int) bool { return *(tags[i].Key) < *(tags[j].Key) }) } - expectedTags := []*ssm.Tag{ + expectedTags := []*types.Tag{ { Key: aws.String("Name"), Value: aws.String("infra-cluster"), @@ -86,6 +117,13 @@ func TestServiceCreate(t *testing.T) { }, } + expectedTagsAsValues := make([]types.Tag, 0, len(expectedTags)) + for _, tagPtr := range expectedTags { + if tagPtr != nil { + expectedTagsAsValues = append(expectedTagsAsValues, *tagPtr) + } + } + tests := []struct { name string bytesCount int64 @@ -106,14 +144,28 @@ func TestServiceCreate(t *testing.T) { secretPrefix: "prefix", expectedPrefix: "/prefix", expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.PutParameter(gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).MinTimes(1).Return(&ssm.PutParameterOutput{}, nil).Do( - func(putParameterInput *ssm.PutParameterInput) { + m.PutParameter(context.TODO(), gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).MinTimes(1).Return(&ssm.PutParameterOutput{}, nil).Do( + func(ctx context.Context, putParameterInput *ssm.PutParameterInput, optFns ...func(*ssm.Options)) { if !strings.HasPrefix(*(putParameterInput.Name), "/prefix/") { t.Fatalf("Prefix is not as expected: %v", putParameterInput.Name) } + sortTagsByKey(putParameterInput.Tags) - if !cmp.Equal(putParameterInput.Tags, expectedTags) { - t.Fatalf("Tags are not as expected, actual: %v, expected: %v", putParameterInput.Tags, expectedTags) + sortTagsByKey(expectedTagsAsValues) + + if diff := cmp.Diff(expectedTagsAsValues, putParameterInput.Tags, + // This Comparer is the key. It tells cmp how to properly compare two Tag structs. + cmp.Comparer(func(x, y types.Tag) bool { + // Safely compare the string content of the Key field. + keyMatch := (x.Key == nil && y.Key == nil) || (x.Key != nil && y.Key != nil && *x.Key == *y.Key) + // Safely compare the string content of the Value field. + valueMatch := (x.Value == nil && y.Value == nil) || (x.Value != nil && y.Value != nil && *x.Value == *y.Value) + + // The tags are equal only if both their key and value content match. + return keyMatch && valueMatch + }), + ); diff != "" { + t.Fatalf("Tags mismatch (-expected +actual):\n%s", diff) } }, ) @@ -126,14 +178,28 @@ func TestServiceCreate(t *testing.T) { expectedPrefix: "/prefix", wantErr: true, expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.PutParameter(gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).Return(nil, &ssm.ParameterAlreadyExists{}).Do( - func(putParameterInput *ssm.PutParameterInput) { + m.PutParameter(context.TODO(), gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).Return(nil, &mockAPIError{ + "ParameterAlreadyExists", + "parameter already exists"}).Do( + func(ctx context.Context, putParameterInput *ssm.PutParameterInput, optFns ...func(*ssm.Options)) { if !strings.HasPrefix(*(putParameterInput.Name), "/prefix/") { t.Fatalf("Prefix is not as expected: %v", putParameterInput.Name) } sortTagsByKey(putParameterInput.Tags) - if !cmp.Equal(putParameterInput.Tags, expectedTags) { - t.Fatalf("Tags are not as expected, actual: %v, expected: %v", putParameterInput.Tags, expectedTags) + sortTagsByKey(expectedTagsAsValues) + if diff := cmp.Diff(expectedTagsAsValues, putParameterInput.Tags, + // This Comparer is the key. It tells cmp how to properly compare two Tag structs. + cmp.Comparer(func(x, y types.Tag) bool { + // Safely compare the string content of the Key field. + keyMatch := (x.Key == nil && y.Key == nil) || (x.Key != nil && y.Key != nil && *x.Key == *y.Key) + // Safely compare the string content of the Value field. + valueMatch := (x.Value == nil && y.Value == nil) || (x.Value != nil && y.Value != nil && *x.Value == *y.Value) + + // The tags are equal only if both their key and value content match. + return keyMatch && valueMatch + }), + ); diff != "" { + t.Fatalf("Tags mismatch (-expected +actual):\n%s", diff) } }, ) @@ -145,8 +211,9 @@ func TestServiceCreate(t *testing.T) { secretPrefix: "", expectedPrefix: "/cluster.x-k8s.io", expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.PutParameter(gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).Return(nil, &ssm.ParameterLimitExceeded{}) - m.PutParameter(gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).Return(&ssm.PutParameterOutput{}, nil) + m.PutParameter(context.TODO(), gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).Return(nil, &mockAPIError{ + "ParameterLimitExceeded", + "parameter limit exceeded"}) }, }, } @@ -197,7 +264,7 @@ func TestServiceDelete(t *testing.T) { name: "Should not return error when delete is successful", secretCount: 1, expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.DeleteParameter(gomock.Eq(&ssm.DeleteParameterInput{ + m.DeleteParameter(context.TODO(), gomock.Eq(&ssm.DeleteParameterInput{ Name: aws.String("prefix/0"), })).Return(&ssm.DeleteParameterOutput{}, nil) }, @@ -206,13 +273,16 @@ func TestServiceDelete(t *testing.T) { name: "Should return all errors except not found errors", secretCount: 3, expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { - m.DeleteParameter(gomock.Eq(&ssm.DeleteParameterInput{ + m.DeleteParameter(context.TODO(), gomock.Eq(&ssm.DeleteParameterInput{ Name: aws.String("prefix/0"), })).Return(nil, awserrors.NewFailedDependency("failed dependency")) - m.DeleteParameter(gomock.Eq(&ssm.DeleteParameterInput{ + m.DeleteParameter(context.TODO(), gomock.Eq(&ssm.DeleteParameterInput{ Name: aws.String("prefix/1"), - })).Return(nil, awserrors.NewNotFound("not found")) - m.DeleteParameter(gomock.Eq(&ssm.DeleteParameterInput{ + })).Return(nil, &mockAPIError{ + Code: "ParameterNotFound", + Message: "not found", + }) + m.DeleteParameter(context.TODO(), gomock.Eq(&ssm.DeleteParameterInput{ Name: aws.String("prefix/2"), })).Return(nil, awserrors.NewConflict("new conflict")) }, diff --git a/pkg/cloud/services/ssm/service.go b/pkg/cloud/services/ssm/service.go index 276e36c21f..ca8b729d9b 100644 --- a/pkg/cloud/services/ssm/service.go +++ b/pkg/cloud/services/ssm/service.go @@ -17,7 +17,9 @@ limitations under the License. package ssm import ( - "github.com/aws/aws-sdk-go/service/ssm/ssmiface" + "context" + + "github.com/aws/aws-sdk-go-v2/service/ssm" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" @@ -28,10 +30,21 @@ import ( // One alternative is to have a large list of functions from the ec2 client. type Service struct { scope cloud.ClusterScoper - SSMClient ssmiface.SSMAPI + SSMClient SSMAPI +} + +// SSMAPI defines the interface for interacting with AWS SSM Parameter Store. +type SSMAPI interface { + PutParameter(ctx context.Context, input *ssm.PutParameterInput, optFns ...func(*ssm.Options)) (*ssm.PutParameterOutput, error) + DeleteParameter(ctx context.Context, input *ssm.DeleteParameterInput, optFns ...func(*ssm.Options)) (*ssm.DeleteParameterOutput, error) + GetParameter(ctx context.Context, input *ssm.GetParameterInput, optFns ...func(*ssm.Options)) (*ssm.GetParameterOutput, error) + // Add more methods as needed } -// NewService returns a new service given the api clients. +// Ensure ssm.Client satisfies the SSMAPI interface. +var _ SSMAPI = &ssm.Client{} + +// NewService creates a new Service for managing secrets in AWS SSM. func NewService(secretsScope cloud.ClusterScoper) *Service { return &Service{ scope: secretsScope,