From a673d13ef562f1ecdd4b34cc40ea813e9db47a84 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 11 Sep 2024 11:51:47 -0600 Subject: [PATCH 1/5] fix(route53-resolver-rule): guard against nil pointers --- ...lver-rules.go => route53-resolver-rule.go} | 40 +++++++++---------- 1 file changed, 19 insertions(+), 21 deletions(-) rename resources/{route53-resolver-rules.go => route53-resolver-rule.go} (84%) diff --git a/resources/route53-resolver-rules.go b/resources/route53-resolver-rule.go similarity index 84% rename from resources/route53-resolver-rules.go rename to resources/route53-resolver-rule.go index 4f6d7ab0..b9e21771 100644 --- a/resources/route53-resolver-rules.go +++ b/resources/route53-resolver-rule.go @@ -31,16 +31,15 @@ type Route53ResolverRuleLister struct{} // List returns a list of all Route53 ResolverRules before filtering to be nuked func (l *Route53ResolverRuleLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + var resources []resource.Resource svc := route53resolver.New(opts.Session) - vpcAssociations, err := resolverRulesToVpcIDs(svc) - if err != nil { - return nil, err + vpcAssociations, vpcErr := resolverRulesToVpcIDs(svc) + if vpcErr != nil { + return nil, vpcErr } - var resources []resource.Resource - params := &route53resolver.ListResolverRulesInput{} for { resp, err := svc.ListResolverRules(params) @@ -52,10 +51,10 @@ func (l *Route53ResolverRuleLister) List(_ context.Context, o interface{}) ([]re for _, rule := range resp.ResolverRules { resources = append(resources, &Route53ResolverRule{ svc: svc, - id: rule.Id, - name: rule.Name, - domainName: rule.DomainName, vpcIds: vpcAssociations[*rule.Id], + ID: rule.Id, + Name: rule.Name, + DomainName: rule.DomainName, }) } @@ -108,20 +107,21 @@ func resolverRulesToVpcIDs(svc *route53resolver.Route53Resolver) (map[string][]* // Route53ResolverRule is the resource type type Route53ResolverRule struct { svc *route53resolver.Route53Resolver - id *string - name *string - domainName *string vpcIds []*string + ID *string + Name *string + DomainName *string } // Filter removes resources automatically from being nuked func (r *Route53ResolverRule) Filter() error { - if r.domainName != nil && ptr.ToString(r.domainName) == "." { - return fmt.Errorf(`filtering DomainName "."`) + if strings.HasPrefix(ptr.ToString(r.ID), "rslvr-autodefined-rr") { + return fmt.Errorf("cannot delete system defined rules") } - if r.id != nil && strings.HasPrefix(ptr.ToString(r.id), "rslvr-autodefined-rr") { - return fmt.Errorf("cannot delete system defined rules") + // TODO: is this needed if the system defined is already filtered? + if r.DomainName != nil && ptr.ToString(r.DomainName) == "." { + return fmt.Errorf(`filtering DomainName "."`) } return nil @@ -131,7 +131,7 @@ func (r *Route53ResolverRule) Filter() error { func (r *Route53ResolverRule) Remove(_ context.Context) error { for _, vpcID := range r.vpcIds { _, err := r.svc.DisassociateResolverRule(&route53resolver.DisassociateResolverRuleInput{ - ResolverRuleId: r.id, + ResolverRuleId: r.ID, VPCId: vpcID, }) @@ -141,7 +141,7 @@ func (r *Route53ResolverRule) Remove(_ context.Context) error { } _, err := r.svc.DeleteResolverRule(&route53resolver.DeleteResolverRuleInput{ - ResolverRuleId: r.id, + ResolverRuleId: r.ID, }) return err @@ -149,12 +149,10 @@ func (r *Route53ResolverRule) Remove(_ context.Context) error { // Properties provides debugging output func (r *Route53ResolverRule) Properties() types.Properties { - return types.NewProperties(). - Set("ID", r.id). - Set("Name", r.name) + return types.NewPropertiesFromStruct(r) } // String implements Stringer func (r *Route53ResolverRule) String() string { - return fmt.Sprintf("%s (%s)", *r.id, *r.name) + return fmt.Sprintf("%s (%s)", ptr.ToString(r.ID), ptr.ToString(r.Name)) } From e75b62bdec73c622f28f8ca84b7a925a5b2edd13 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 11 Sep 2024 11:53:01 -0600 Subject: [PATCH 2/5] test(route53): adding mocks for testing route53 --- mocks/mock_route53iface/mock.go | 3801 +++++++++++++++++++++++++++++++ resources/route53_mock_test.go | 4 + 2 files changed, 3805 insertions(+) create mode 100644 mocks/mock_route53iface/mock.go create mode 100644 resources/route53_mock_test.go diff --git a/mocks/mock_route53iface/mock.go b/mocks/mock_route53iface/mock.go new file mode 100644 index 00000000..c7d73ef0 --- /dev/null +++ b/mocks/mock_route53iface/mock.go @@ -0,0 +1,3801 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/ekristen/go/pkg/mod/github.com/aws/aws-sdk-go@v1.54.20/service/route53/route53iface/interface.go + +// Package mock_route53iface is a generated GoMock package. +package mock_route53iface + +import ( + reflect "reflect" + + aws "github.com/aws/aws-sdk-go/aws" + request "github.com/aws/aws-sdk-go/aws/request" + route53 "github.com/aws/aws-sdk-go/service/route53" + gomock "github.com/golang/mock/gomock" +) + +// MockRoute53API is a mock of Route53API interface. +type MockRoute53API struct { + ctrl *gomock.Controller + recorder *MockRoute53APIMockRecorder +} + +// MockRoute53APIMockRecorder is the mock recorder for MockRoute53API. +type MockRoute53APIMockRecorder struct { + mock *MockRoute53API +} + +// NewMockRoute53API creates a new mock instance. +func NewMockRoute53API(ctrl *gomock.Controller) *MockRoute53API { + mock := &MockRoute53API{ctrl: ctrl} + mock.recorder = &MockRoute53APIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRoute53API) EXPECT() *MockRoute53APIMockRecorder { + return m.recorder +} + +// ActivateKeySigningKey mocks base method. +func (m *MockRoute53API) ActivateKeySigningKey(arg0 *route53.ActivateKeySigningKeyInput) (*route53.ActivateKeySigningKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ActivateKeySigningKey", arg0) + ret0, _ := ret[0].(*route53.ActivateKeySigningKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ActivateKeySigningKey indicates an expected call of ActivateKeySigningKey. +func (mr *MockRoute53APIMockRecorder) ActivateKeySigningKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateKeySigningKey", reflect.TypeOf((*MockRoute53API)(nil).ActivateKeySigningKey), arg0) +} + +// ActivateKeySigningKeyRequest mocks base method. +func (m *MockRoute53API) ActivateKeySigningKeyRequest(arg0 *route53.ActivateKeySigningKeyInput) (*request.Request, *route53.ActivateKeySigningKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ActivateKeySigningKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ActivateKeySigningKeyOutput) + return ret0, ret1 +} + +// ActivateKeySigningKeyRequest indicates an expected call of ActivateKeySigningKeyRequest. +func (mr *MockRoute53APIMockRecorder) ActivateKeySigningKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateKeySigningKeyRequest", reflect.TypeOf((*MockRoute53API)(nil).ActivateKeySigningKeyRequest), arg0) +} + +// ActivateKeySigningKeyWithContext mocks base method. +func (m *MockRoute53API) ActivateKeySigningKeyWithContext(arg0 aws.Context, arg1 *route53.ActivateKeySigningKeyInput, arg2 ...request.Option) (*route53.ActivateKeySigningKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ActivateKeySigningKeyWithContext", varargs...) + ret0, _ := ret[0].(*route53.ActivateKeySigningKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ActivateKeySigningKeyWithContext indicates an expected call of ActivateKeySigningKeyWithContext. +func (mr *MockRoute53APIMockRecorder) ActivateKeySigningKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateKeySigningKeyWithContext", reflect.TypeOf((*MockRoute53API)(nil).ActivateKeySigningKeyWithContext), varargs...) +} + +// AssociateVPCWithHostedZone mocks base method. +func (m *MockRoute53API) AssociateVPCWithHostedZone(arg0 *route53.AssociateVPCWithHostedZoneInput) (*route53.AssociateVPCWithHostedZoneOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateVPCWithHostedZone", arg0) + ret0, _ := ret[0].(*route53.AssociateVPCWithHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateVPCWithHostedZone indicates an expected call of AssociateVPCWithHostedZone. +func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZone(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZone", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZone), arg0) +} + +// AssociateVPCWithHostedZoneRequest mocks base method. +func (m *MockRoute53API) AssociateVPCWithHostedZoneRequest(arg0 *route53.AssociateVPCWithHostedZoneInput) (*request.Request, *route53.AssociateVPCWithHostedZoneOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateVPCWithHostedZoneRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.AssociateVPCWithHostedZoneOutput) + return ret0, ret1 +} + +// AssociateVPCWithHostedZoneRequest indicates an expected call of AssociateVPCWithHostedZoneRequest. +func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZoneRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZoneRequest), arg0) +} + +// AssociateVPCWithHostedZoneWithContext mocks base method. +func (m *MockRoute53API) AssociateVPCWithHostedZoneWithContext(arg0 aws.Context, arg1 *route53.AssociateVPCWithHostedZoneInput, arg2 ...request.Option) (*route53.AssociateVPCWithHostedZoneOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateVPCWithHostedZoneWithContext", varargs...) + ret0, _ := ret[0].(*route53.AssociateVPCWithHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateVPCWithHostedZoneWithContext indicates an expected call of AssociateVPCWithHostedZoneWithContext. +func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZoneWithContext), varargs...) +} + +// ChangeCidrCollection mocks base method. +func (m *MockRoute53API) ChangeCidrCollection(arg0 *route53.ChangeCidrCollectionInput) (*route53.ChangeCidrCollectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangeCidrCollection", arg0) + ret0, _ := ret[0].(*route53.ChangeCidrCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeCidrCollection indicates an expected call of ChangeCidrCollection. +func (mr *MockRoute53APIMockRecorder) ChangeCidrCollection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeCidrCollection", reflect.TypeOf((*MockRoute53API)(nil).ChangeCidrCollection), arg0) +} + +// ChangeCidrCollectionRequest mocks base method. +func (m *MockRoute53API) ChangeCidrCollectionRequest(arg0 *route53.ChangeCidrCollectionInput) (*request.Request, *route53.ChangeCidrCollectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangeCidrCollectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ChangeCidrCollectionOutput) + return ret0, ret1 +} + +// ChangeCidrCollectionRequest indicates an expected call of ChangeCidrCollectionRequest. +func (mr *MockRoute53APIMockRecorder) ChangeCidrCollectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeCidrCollectionRequest", reflect.TypeOf((*MockRoute53API)(nil).ChangeCidrCollectionRequest), arg0) +} + +// ChangeCidrCollectionWithContext mocks base method. +func (m *MockRoute53API) ChangeCidrCollectionWithContext(arg0 aws.Context, arg1 *route53.ChangeCidrCollectionInput, arg2 ...request.Option) (*route53.ChangeCidrCollectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangeCidrCollectionWithContext", varargs...) + ret0, _ := ret[0].(*route53.ChangeCidrCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeCidrCollectionWithContext indicates an expected call of ChangeCidrCollectionWithContext. +func (mr *MockRoute53APIMockRecorder) ChangeCidrCollectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeCidrCollectionWithContext", reflect.TypeOf((*MockRoute53API)(nil).ChangeCidrCollectionWithContext), varargs...) +} + +// ChangeResourceRecordSets mocks base method. +func (m *MockRoute53API) ChangeResourceRecordSets(arg0 *route53.ChangeResourceRecordSetsInput) (*route53.ChangeResourceRecordSetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangeResourceRecordSets", arg0) + ret0, _ := ret[0].(*route53.ChangeResourceRecordSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeResourceRecordSets indicates an expected call of ChangeResourceRecordSets. +func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSets", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSets), arg0) +} + +// ChangeResourceRecordSetsRequest mocks base method. +func (m *MockRoute53API) ChangeResourceRecordSetsRequest(arg0 *route53.ChangeResourceRecordSetsInput) (*request.Request, *route53.ChangeResourceRecordSetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangeResourceRecordSetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ChangeResourceRecordSetsOutput) + return ret0, ret1 +} + +// ChangeResourceRecordSetsRequest indicates an expected call of ChangeResourceRecordSetsRequest. +func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSetsRequest), arg0) +} + +// ChangeResourceRecordSetsWithContext mocks base method. +func (m *MockRoute53API) ChangeResourceRecordSetsWithContext(arg0 aws.Context, arg1 *route53.ChangeResourceRecordSetsInput, arg2 ...request.Option) (*route53.ChangeResourceRecordSetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangeResourceRecordSetsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ChangeResourceRecordSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeResourceRecordSetsWithContext indicates an expected call of ChangeResourceRecordSetsWithContext. +func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSetsWithContext), varargs...) +} + +// ChangeTagsForResource mocks base method. +func (m *MockRoute53API) ChangeTagsForResource(arg0 *route53.ChangeTagsForResourceInput) (*route53.ChangeTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangeTagsForResource", arg0) + ret0, _ := ret[0].(*route53.ChangeTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeTagsForResource indicates an expected call of ChangeTagsForResource. +func (mr *MockRoute53APIMockRecorder) ChangeTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResource", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResource), arg0) +} + +// ChangeTagsForResourceRequest mocks base method. +func (m *MockRoute53API) ChangeTagsForResourceRequest(arg0 *route53.ChangeTagsForResourceInput) (*request.Request, *route53.ChangeTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangeTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ChangeTagsForResourceOutput) + return ret0, ret1 +} + +// ChangeTagsForResourceRequest indicates an expected call of ChangeTagsForResourceRequest. +func (mr *MockRoute53APIMockRecorder) ChangeTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResourceRequest", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResourceRequest), arg0) +} + +// ChangeTagsForResourceWithContext mocks base method. +func (m *MockRoute53API) ChangeTagsForResourceWithContext(arg0 aws.Context, arg1 *route53.ChangeTagsForResourceInput, arg2 ...request.Option) (*route53.ChangeTagsForResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangeTagsForResourceWithContext", varargs...) + ret0, _ := ret[0].(*route53.ChangeTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeTagsForResourceWithContext indicates an expected call of ChangeTagsForResourceWithContext. +func (mr *MockRoute53APIMockRecorder) ChangeTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResourceWithContext", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResourceWithContext), varargs...) +} + +// CreateCidrCollection mocks base method. +func (m *MockRoute53API) CreateCidrCollection(arg0 *route53.CreateCidrCollectionInput) (*route53.CreateCidrCollectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCidrCollection", arg0) + ret0, _ := ret[0].(*route53.CreateCidrCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCidrCollection indicates an expected call of CreateCidrCollection. +func (mr *MockRoute53APIMockRecorder) CreateCidrCollection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCidrCollection", reflect.TypeOf((*MockRoute53API)(nil).CreateCidrCollection), arg0) +} + +// CreateCidrCollectionRequest mocks base method. +func (m *MockRoute53API) CreateCidrCollectionRequest(arg0 *route53.CreateCidrCollectionInput) (*request.Request, *route53.CreateCidrCollectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCidrCollectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateCidrCollectionOutput) + return ret0, ret1 +} + +// CreateCidrCollectionRequest indicates an expected call of CreateCidrCollectionRequest. +func (mr *MockRoute53APIMockRecorder) CreateCidrCollectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCidrCollectionRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateCidrCollectionRequest), arg0) +} + +// CreateCidrCollectionWithContext mocks base method. +func (m *MockRoute53API) CreateCidrCollectionWithContext(arg0 aws.Context, arg1 *route53.CreateCidrCollectionInput, arg2 ...request.Option) (*route53.CreateCidrCollectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateCidrCollectionWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateCidrCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCidrCollectionWithContext indicates an expected call of CreateCidrCollectionWithContext. +func (mr *MockRoute53APIMockRecorder) CreateCidrCollectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCidrCollectionWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateCidrCollectionWithContext), varargs...) +} + +// CreateHealthCheck mocks base method. +func (m *MockRoute53API) CreateHealthCheck(arg0 *route53.CreateHealthCheckInput) (*route53.CreateHealthCheckOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateHealthCheck", arg0) + ret0, _ := ret[0].(*route53.CreateHealthCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateHealthCheck indicates an expected call of CreateHealthCheck. +func (mr *MockRoute53APIMockRecorder) CreateHealthCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheck), arg0) +} + +// CreateHealthCheckRequest mocks base method. +func (m *MockRoute53API) CreateHealthCheckRequest(arg0 *route53.CreateHealthCheckInput) (*request.Request, *route53.CreateHealthCheckOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateHealthCheckRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateHealthCheckOutput) + return ret0, ret1 +} + +// CreateHealthCheckRequest indicates an expected call of CreateHealthCheckRequest. +func (mr *MockRoute53APIMockRecorder) CreateHealthCheckRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheckRequest), arg0) +} + +// CreateHealthCheckWithContext mocks base method. +func (m *MockRoute53API) CreateHealthCheckWithContext(arg0 aws.Context, arg1 *route53.CreateHealthCheckInput, arg2 ...request.Option) (*route53.CreateHealthCheckOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateHealthCheckWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateHealthCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateHealthCheckWithContext indicates an expected call of CreateHealthCheckWithContext. +func (mr *MockRoute53APIMockRecorder) CreateHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheckWithContext), varargs...) +} + +// CreateHostedZone mocks base method. +func (m *MockRoute53API) CreateHostedZone(arg0 *route53.CreateHostedZoneInput) (*route53.CreateHostedZoneOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateHostedZone", arg0) + ret0, _ := ret[0].(*route53.CreateHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateHostedZone indicates an expected call of CreateHostedZone. +func (mr *MockRoute53APIMockRecorder) CreateHostedZone(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZone", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZone), arg0) +} + +// CreateHostedZoneRequest mocks base method. +func (m *MockRoute53API) CreateHostedZoneRequest(arg0 *route53.CreateHostedZoneInput) (*request.Request, *route53.CreateHostedZoneOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateHostedZoneRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateHostedZoneOutput) + return ret0, ret1 +} + +// CreateHostedZoneRequest indicates an expected call of CreateHostedZoneRequest. +func (mr *MockRoute53APIMockRecorder) CreateHostedZoneRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZoneRequest), arg0) +} + +// CreateHostedZoneWithContext mocks base method. +func (m *MockRoute53API) CreateHostedZoneWithContext(arg0 aws.Context, arg1 *route53.CreateHostedZoneInput, arg2 ...request.Option) (*route53.CreateHostedZoneOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateHostedZoneWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateHostedZoneWithContext indicates an expected call of CreateHostedZoneWithContext. +func (mr *MockRoute53APIMockRecorder) CreateHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZoneWithContext), varargs...) +} + +// CreateKeySigningKey mocks base method. +func (m *MockRoute53API) CreateKeySigningKey(arg0 *route53.CreateKeySigningKeyInput) (*route53.CreateKeySigningKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateKeySigningKey", arg0) + ret0, _ := ret[0].(*route53.CreateKeySigningKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateKeySigningKey indicates an expected call of CreateKeySigningKey. +func (mr *MockRoute53APIMockRecorder) CreateKeySigningKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeySigningKey", reflect.TypeOf((*MockRoute53API)(nil).CreateKeySigningKey), arg0) +} + +// CreateKeySigningKeyRequest mocks base method. +func (m *MockRoute53API) CreateKeySigningKeyRequest(arg0 *route53.CreateKeySigningKeyInput) (*request.Request, *route53.CreateKeySigningKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateKeySigningKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateKeySigningKeyOutput) + return ret0, ret1 +} + +// CreateKeySigningKeyRequest indicates an expected call of CreateKeySigningKeyRequest. +func (mr *MockRoute53APIMockRecorder) CreateKeySigningKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeySigningKeyRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateKeySigningKeyRequest), arg0) +} + +// CreateKeySigningKeyWithContext mocks base method. +func (m *MockRoute53API) CreateKeySigningKeyWithContext(arg0 aws.Context, arg1 *route53.CreateKeySigningKeyInput, arg2 ...request.Option) (*route53.CreateKeySigningKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateKeySigningKeyWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateKeySigningKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateKeySigningKeyWithContext indicates an expected call of CreateKeySigningKeyWithContext. +func (mr *MockRoute53APIMockRecorder) CreateKeySigningKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeySigningKeyWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateKeySigningKeyWithContext), varargs...) +} + +// CreateQueryLoggingConfig mocks base method. +func (m *MockRoute53API) CreateQueryLoggingConfig(arg0 *route53.CreateQueryLoggingConfigInput) (*route53.CreateQueryLoggingConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateQueryLoggingConfig", arg0) + ret0, _ := ret[0].(*route53.CreateQueryLoggingConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateQueryLoggingConfig indicates an expected call of CreateQueryLoggingConfig. +func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfig), arg0) +} + +// CreateQueryLoggingConfigRequest mocks base method. +func (m *MockRoute53API) CreateQueryLoggingConfigRequest(arg0 *route53.CreateQueryLoggingConfigInput) (*request.Request, *route53.CreateQueryLoggingConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateQueryLoggingConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateQueryLoggingConfigOutput) + return ret0, ret1 +} + +// CreateQueryLoggingConfigRequest indicates an expected call of CreateQueryLoggingConfigRequest. +func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfigRequest), arg0) +} + +// CreateQueryLoggingConfigWithContext mocks base method. +func (m *MockRoute53API) CreateQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.CreateQueryLoggingConfigInput, arg2 ...request.Option) (*route53.CreateQueryLoggingConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateQueryLoggingConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateQueryLoggingConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateQueryLoggingConfigWithContext indicates an expected call of CreateQueryLoggingConfigWithContext. +func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfigWithContext), varargs...) +} + +// CreateReusableDelegationSet mocks base method. +func (m *MockRoute53API) CreateReusableDelegationSet(arg0 *route53.CreateReusableDelegationSetInput) (*route53.CreateReusableDelegationSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateReusableDelegationSet", arg0) + ret0, _ := ret[0].(*route53.CreateReusableDelegationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateReusableDelegationSet indicates an expected call of CreateReusableDelegationSet. +func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSet), arg0) +} + +// CreateReusableDelegationSetRequest mocks base method. +func (m *MockRoute53API) CreateReusableDelegationSetRequest(arg0 *route53.CreateReusableDelegationSetInput) (*request.Request, *route53.CreateReusableDelegationSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateReusableDelegationSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateReusableDelegationSetOutput) + return ret0, ret1 +} + +// CreateReusableDelegationSetRequest indicates an expected call of CreateReusableDelegationSetRequest. +func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSetRequest), arg0) +} + +// CreateReusableDelegationSetWithContext mocks base method. +func (m *MockRoute53API) CreateReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.CreateReusableDelegationSetInput, arg2 ...request.Option) (*route53.CreateReusableDelegationSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateReusableDelegationSetWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateReusableDelegationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateReusableDelegationSetWithContext indicates an expected call of CreateReusableDelegationSetWithContext. +func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSetWithContext), varargs...) +} + +// CreateTrafficPolicy mocks base method. +func (m *MockRoute53API) CreateTrafficPolicy(arg0 *route53.CreateTrafficPolicyInput) (*route53.CreateTrafficPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficPolicy", arg0) + ret0, _ := ret[0].(*route53.CreateTrafficPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficPolicy indicates an expected call of CreateTrafficPolicy. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicy), arg0) +} + +// CreateTrafficPolicyInstance mocks base method. +func (m *MockRoute53API) CreateTrafficPolicyInstance(arg0 *route53.CreateTrafficPolicyInstanceInput) (*route53.CreateTrafficPolicyInstanceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficPolicyInstance", arg0) + ret0, _ := ret[0].(*route53.CreateTrafficPolicyInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficPolicyInstance indicates an expected call of CreateTrafficPolicyInstance. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstance), arg0) +} + +// CreateTrafficPolicyInstanceRequest mocks base method. +func (m *MockRoute53API) CreateTrafficPolicyInstanceRequest(arg0 *route53.CreateTrafficPolicyInstanceInput) (*request.Request, *route53.CreateTrafficPolicyInstanceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficPolicyInstanceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateTrafficPolicyInstanceOutput) + return ret0, ret1 +} + +// CreateTrafficPolicyInstanceRequest indicates an expected call of CreateTrafficPolicyInstanceRequest. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstanceRequest), arg0) +} + +// CreateTrafficPolicyInstanceWithContext mocks base method. +func (m *MockRoute53API) CreateTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyInstanceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTrafficPolicyInstanceWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateTrafficPolicyInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficPolicyInstanceWithContext indicates an expected call of CreateTrafficPolicyInstanceWithContext. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstanceWithContext), varargs...) +} + +// CreateTrafficPolicyRequest mocks base method. +func (m *MockRoute53API) CreateTrafficPolicyRequest(arg0 *route53.CreateTrafficPolicyInput) (*request.Request, *route53.CreateTrafficPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateTrafficPolicyOutput) + return ret0, ret1 +} + +// CreateTrafficPolicyRequest indicates an expected call of CreateTrafficPolicyRequest. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyRequest), arg0) +} + +// CreateTrafficPolicyVersion mocks base method. +func (m *MockRoute53API) CreateTrafficPolicyVersion(arg0 *route53.CreateTrafficPolicyVersionInput) (*route53.CreateTrafficPolicyVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficPolicyVersion", arg0) + ret0, _ := ret[0].(*route53.CreateTrafficPolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficPolicyVersion indicates an expected call of CreateTrafficPolicyVersion. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersion", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersion), arg0) +} + +// CreateTrafficPolicyVersionRequest mocks base method. +func (m *MockRoute53API) CreateTrafficPolicyVersionRequest(arg0 *route53.CreateTrafficPolicyVersionInput) (*request.Request, *route53.CreateTrafficPolicyVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficPolicyVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateTrafficPolicyVersionOutput) + return ret0, ret1 +} + +// CreateTrafficPolicyVersionRequest indicates an expected call of CreateTrafficPolicyVersionRequest. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersionRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersionRequest), arg0) +} + +// CreateTrafficPolicyVersionWithContext mocks base method. +func (m *MockRoute53API) CreateTrafficPolicyVersionWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyVersionInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTrafficPolicyVersionWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateTrafficPolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficPolicyVersionWithContext indicates an expected call of CreateTrafficPolicyVersionWithContext. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersionWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersionWithContext), varargs...) +} + +// CreateTrafficPolicyWithContext mocks base method. +func (m *MockRoute53API) CreateTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTrafficPolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateTrafficPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficPolicyWithContext indicates an expected call of CreateTrafficPolicyWithContext. +func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyWithContext), varargs...) +} + +// CreateVPCAssociationAuthorization mocks base method. +func (m *MockRoute53API) CreateVPCAssociationAuthorization(arg0 *route53.CreateVPCAssociationAuthorizationInput) (*route53.CreateVPCAssociationAuthorizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorization", arg0) + ret0, _ := ret[0].(*route53.CreateVPCAssociationAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVPCAssociationAuthorization indicates an expected call of CreateVPCAssociationAuthorization. +func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorization", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorization), arg0) +} + +// CreateVPCAssociationAuthorizationRequest mocks base method. +func (m *MockRoute53API) CreateVPCAssociationAuthorizationRequest(arg0 *route53.CreateVPCAssociationAuthorizationInput) (*request.Request, *route53.CreateVPCAssociationAuthorizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.CreateVPCAssociationAuthorizationOutput) + return ret0, ret1 +} + +// CreateVPCAssociationAuthorizationRequest indicates an expected call of CreateVPCAssociationAuthorizationRequest. +func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorizationRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorizationRequest), arg0) +} + +// CreateVPCAssociationAuthorizationWithContext mocks base method. +func (m *MockRoute53API) CreateVPCAssociationAuthorizationWithContext(arg0 aws.Context, arg1 *route53.CreateVPCAssociationAuthorizationInput, arg2 ...request.Option) (*route53.CreateVPCAssociationAuthorizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorizationWithContext", varargs...) + ret0, _ := ret[0].(*route53.CreateVPCAssociationAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVPCAssociationAuthorizationWithContext indicates an expected call of CreateVPCAssociationAuthorizationWithContext. +func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorizationWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorizationWithContext), varargs...) +} + +// DeactivateKeySigningKey mocks base method. +func (m *MockRoute53API) DeactivateKeySigningKey(arg0 *route53.DeactivateKeySigningKeyInput) (*route53.DeactivateKeySigningKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeactivateKeySigningKey", arg0) + ret0, _ := ret[0].(*route53.DeactivateKeySigningKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateKeySigningKey indicates an expected call of DeactivateKeySigningKey. +func (mr *MockRoute53APIMockRecorder) DeactivateKeySigningKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateKeySigningKey", reflect.TypeOf((*MockRoute53API)(nil).DeactivateKeySigningKey), arg0) +} + +// DeactivateKeySigningKeyRequest mocks base method. +func (m *MockRoute53API) DeactivateKeySigningKeyRequest(arg0 *route53.DeactivateKeySigningKeyInput) (*request.Request, *route53.DeactivateKeySigningKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeactivateKeySigningKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeactivateKeySigningKeyOutput) + return ret0, ret1 +} + +// DeactivateKeySigningKeyRequest indicates an expected call of DeactivateKeySigningKeyRequest. +func (mr *MockRoute53APIMockRecorder) DeactivateKeySigningKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateKeySigningKeyRequest", reflect.TypeOf((*MockRoute53API)(nil).DeactivateKeySigningKeyRequest), arg0) +} + +// DeactivateKeySigningKeyWithContext mocks base method. +func (m *MockRoute53API) DeactivateKeySigningKeyWithContext(arg0 aws.Context, arg1 *route53.DeactivateKeySigningKeyInput, arg2 ...request.Option) (*route53.DeactivateKeySigningKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateKeySigningKeyWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeactivateKeySigningKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateKeySigningKeyWithContext indicates an expected call of DeactivateKeySigningKeyWithContext. +func (mr *MockRoute53APIMockRecorder) DeactivateKeySigningKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateKeySigningKeyWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeactivateKeySigningKeyWithContext), varargs...) +} + +// DeleteCidrCollection mocks base method. +func (m *MockRoute53API) DeleteCidrCollection(arg0 *route53.DeleteCidrCollectionInput) (*route53.DeleteCidrCollectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCidrCollection", arg0) + ret0, _ := ret[0].(*route53.DeleteCidrCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCidrCollection indicates an expected call of DeleteCidrCollection. +func (mr *MockRoute53APIMockRecorder) DeleteCidrCollection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCidrCollection", reflect.TypeOf((*MockRoute53API)(nil).DeleteCidrCollection), arg0) +} + +// DeleteCidrCollectionRequest mocks base method. +func (m *MockRoute53API) DeleteCidrCollectionRequest(arg0 *route53.DeleteCidrCollectionInput) (*request.Request, *route53.DeleteCidrCollectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCidrCollectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteCidrCollectionOutput) + return ret0, ret1 +} + +// DeleteCidrCollectionRequest indicates an expected call of DeleteCidrCollectionRequest. +func (mr *MockRoute53APIMockRecorder) DeleteCidrCollectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCidrCollectionRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteCidrCollectionRequest), arg0) +} + +// DeleteCidrCollectionWithContext mocks base method. +func (m *MockRoute53API) DeleteCidrCollectionWithContext(arg0 aws.Context, arg1 *route53.DeleteCidrCollectionInput, arg2 ...request.Option) (*route53.DeleteCidrCollectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteCidrCollectionWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteCidrCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCidrCollectionWithContext indicates an expected call of DeleteCidrCollectionWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteCidrCollectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCidrCollectionWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteCidrCollectionWithContext), varargs...) +} + +// DeleteHealthCheck mocks base method. +func (m *MockRoute53API) DeleteHealthCheck(arg0 *route53.DeleteHealthCheckInput) (*route53.DeleteHealthCheckOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteHealthCheck", arg0) + ret0, _ := ret[0].(*route53.DeleteHealthCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteHealthCheck indicates an expected call of DeleteHealthCheck. +func (mr *MockRoute53APIMockRecorder) DeleteHealthCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheck), arg0) +} + +// DeleteHealthCheckRequest mocks base method. +func (m *MockRoute53API) DeleteHealthCheckRequest(arg0 *route53.DeleteHealthCheckInput) (*request.Request, *route53.DeleteHealthCheckOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteHealthCheckRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteHealthCheckOutput) + return ret0, ret1 +} + +// DeleteHealthCheckRequest indicates an expected call of DeleteHealthCheckRequest. +func (mr *MockRoute53APIMockRecorder) DeleteHealthCheckRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheckRequest), arg0) +} + +// DeleteHealthCheckWithContext mocks base method. +func (m *MockRoute53API) DeleteHealthCheckWithContext(arg0 aws.Context, arg1 *route53.DeleteHealthCheckInput, arg2 ...request.Option) (*route53.DeleteHealthCheckOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteHealthCheckWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteHealthCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteHealthCheckWithContext indicates an expected call of DeleteHealthCheckWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheckWithContext), varargs...) +} + +// DeleteHostedZone mocks base method. +func (m *MockRoute53API) DeleteHostedZone(arg0 *route53.DeleteHostedZoneInput) (*route53.DeleteHostedZoneOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteHostedZone", arg0) + ret0, _ := ret[0].(*route53.DeleteHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteHostedZone indicates an expected call of DeleteHostedZone. +func (mr *MockRoute53APIMockRecorder) DeleteHostedZone(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZone", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZone), arg0) +} + +// DeleteHostedZoneRequest mocks base method. +func (m *MockRoute53API) DeleteHostedZoneRequest(arg0 *route53.DeleteHostedZoneInput) (*request.Request, *route53.DeleteHostedZoneOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteHostedZoneRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteHostedZoneOutput) + return ret0, ret1 +} + +// DeleteHostedZoneRequest indicates an expected call of DeleteHostedZoneRequest. +func (mr *MockRoute53APIMockRecorder) DeleteHostedZoneRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZoneRequest), arg0) +} + +// DeleteHostedZoneWithContext mocks base method. +func (m *MockRoute53API) DeleteHostedZoneWithContext(arg0 aws.Context, arg1 *route53.DeleteHostedZoneInput, arg2 ...request.Option) (*route53.DeleteHostedZoneOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteHostedZoneWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteHostedZoneWithContext indicates an expected call of DeleteHostedZoneWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZoneWithContext), varargs...) +} + +// DeleteKeySigningKey mocks base method. +func (m *MockRoute53API) DeleteKeySigningKey(arg0 *route53.DeleteKeySigningKeyInput) (*route53.DeleteKeySigningKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteKeySigningKey", arg0) + ret0, _ := ret[0].(*route53.DeleteKeySigningKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteKeySigningKey indicates an expected call of DeleteKeySigningKey. +func (mr *MockRoute53APIMockRecorder) DeleteKeySigningKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeySigningKey", reflect.TypeOf((*MockRoute53API)(nil).DeleteKeySigningKey), arg0) +} + +// DeleteKeySigningKeyRequest mocks base method. +func (m *MockRoute53API) DeleteKeySigningKeyRequest(arg0 *route53.DeleteKeySigningKeyInput) (*request.Request, *route53.DeleteKeySigningKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteKeySigningKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteKeySigningKeyOutput) + return ret0, ret1 +} + +// DeleteKeySigningKeyRequest indicates an expected call of DeleteKeySigningKeyRequest. +func (mr *MockRoute53APIMockRecorder) DeleteKeySigningKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeySigningKeyRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteKeySigningKeyRequest), arg0) +} + +// DeleteKeySigningKeyWithContext mocks base method. +func (m *MockRoute53API) DeleteKeySigningKeyWithContext(arg0 aws.Context, arg1 *route53.DeleteKeySigningKeyInput, arg2 ...request.Option) (*route53.DeleteKeySigningKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteKeySigningKeyWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteKeySigningKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteKeySigningKeyWithContext indicates an expected call of DeleteKeySigningKeyWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteKeySigningKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeySigningKeyWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteKeySigningKeyWithContext), varargs...) +} + +// DeleteQueryLoggingConfig mocks base method. +func (m *MockRoute53API) DeleteQueryLoggingConfig(arg0 *route53.DeleteQueryLoggingConfigInput) (*route53.DeleteQueryLoggingConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteQueryLoggingConfig", arg0) + ret0, _ := ret[0].(*route53.DeleteQueryLoggingConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteQueryLoggingConfig indicates an expected call of DeleteQueryLoggingConfig. +func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfig), arg0) +} + +// DeleteQueryLoggingConfigRequest mocks base method. +func (m *MockRoute53API) DeleteQueryLoggingConfigRequest(arg0 *route53.DeleteQueryLoggingConfigInput) (*request.Request, *route53.DeleteQueryLoggingConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteQueryLoggingConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteQueryLoggingConfigOutput) + return ret0, ret1 +} + +// DeleteQueryLoggingConfigRequest indicates an expected call of DeleteQueryLoggingConfigRequest. +func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfigRequest), arg0) +} + +// DeleteQueryLoggingConfigWithContext mocks base method. +func (m *MockRoute53API) DeleteQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.DeleteQueryLoggingConfigInput, arg2 ...request.Option) (*route53.DeleteQueryLoggingConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteQueryLoggingConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteQueryLoggingConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteQueryLoggingConfigWithContext indicates an expected call of DeleteQueryLoggingConfigWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfigWithContext), varargs...) +} + +// DeleteReusableDelegationSet mocks base method. +func (m *MockRoute53API) DeleteReusableDelegationSet(arg0 *route53.DeleteReusableDelegationSetInput) (*route53.DeleteReusableDelegationSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteReusableDelegationSet", arg0) + ret0, _ := ret[0].(*route53.DeleteReusableDelegationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteReusableDelegationSet indicates an expected call of DeleteReusableDelegationSet. +func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSet), arg0) +} + +// DeleteReusableDelegationSetRequest mocks base method. +func (m *MockRoute53API) DeleteReusableDelegationSetRequest(arg0 *route53.DeleteReusableDelegationSetInput) (*request.Request, *route53.DeleteReusableDelegationSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteReusableDelegationSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteReusableDelegationSetOutput) + return ret0, ret1 +} + +// DeleteReusableDelegationSetRequest indicates an expected call of DeleteReusableDelegationSetRequest. +func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSetRequest), arg0) +} + +// DeleteReusableDelegationSetWithContext mocks base method. +func (m *MockRoute53API) DeleteReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.DeleteReusableDelegationSetInput, arg2 ...request.Option) (*route53.DeleteReusableDelegationSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteReusableDelegationSetWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteReusableDelegationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteReusableDelegationSetWithContext indicates an expected call of DeleteReusableDelegationSetWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSetWithContext), varargs...) +} + +// DeleteTrafficPolicy mocks base method. +func (m *MockRoute53API) DeleteTrafficPolicy(arg0 *route53.DeleteTrafficPolicyInput) (*route53.DeleteTrafficPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficPolicy", arg0) + ret0, _ := ret[0].(*route53.DeleteTrafficPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficPolicy indicates an expected call of DeleteTrafficPolicy. +func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicy), arg0) +} + +// DeleteTrafficPolicyInstance mocks base method. +func (m *MockRoute53API) DeleteTrafficPolicyInstance(arg0 *route53.DeleteTrafficPolicyInstanceInput) (*route53.DeleteTrafficPolicyInstanceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstance", arg0) + ret0, _ := ret[0].(*route53.DeleteTrafficPolicyInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficPolicyInstance indicates an expected call of DeleteTrafficPolicyInstance. +func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstance), arg0) +} + +// DeleteTrafficPolicyInstanceRequest mocks base method. +func (m *MockRoute53API) DeleteTrafficPolicyInstanceRequest(arg0 *route53.DeleteTrafficPolicyInstanceInput) (*request.Request, *route53.DeleteTrafficPolicyInstanceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstanceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteTrafficPolicyInstanceOutput) + return ret0, ret1 +} + +// DeleteTrafficPolicyInstanceRequest indicates an expected call of DeleteTrafficPolicyInstanceRequest. +func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstanceRequest), arg0) +} + +// DeleteTrafficPolicyInstanceWithContext mocks base method. +func (m *MockRoute53API) DeleteTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.DeleteTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.DeleteTrafficPolicyInstanceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstanceWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteTrafficPolicyInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficPolicyInstanceWithContext indicates an expected call of DeleteTrafficPolicyInstanceWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstanceWithContext), varargs...) +} + +// DeleteTrafficPolicyRequest mocks base method. +func (m *MockRoute53API) DeleteTrafficPolicyRequest(arg0 *route53.DeleteTrafficPolicyInput) (*request.Request, *route53.DeleteTrafficPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteTrafficPolicyOutput) + return ret0, ret1 +} + +// DeleteTrafficPolicyRequest indicates an expected call of DeleteTrafficPolicyRequest. +func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyRequest), arg0) +} + +// DeleteTrafficPolicyWithContext mocks base method. +func (m *MockRoute53API) DeleteTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.DeleteTrafficPolicyInput, arg2 ...request.Option) (*route53.DeleteTrafficPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTrafficPolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteTrafficPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficPolicyWithContext indicates an expected call of DeleteTrafficPolicyWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyWithContext), varargs...) +} + +// DeleteVPCAssociationAuthorization mocks base method. +func (m *MockRoute53API) DeleteVPCAssociationAuthorization(arg0 *route53.DeleteVPCAssociationAuthorizationInput) (*route53.DeleteVPCAssociationAuthorizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorization", arg0) + ret0, _ := ret[0].(*route53.DeleteVPCAssociationAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVPCAssociationAuthorization indicates an expected call of DeleteVPCAssociationAuthorization. +func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorization", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorization), arg0) +} + +// DeleteVPCAssociationAuthorizationRequest mocks base method. +func (m *MockRoute53API) DeleteVPCAssociationAuthorizationRequest(arg0 *route53.DeleteVPCAssociationAuthorizationInput) (*request.Request, *route53.DeleteVPCAssociationAuthorizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DeleteVPCAssociationAuthorizationOutput) + return ret0, ret1 +} + +// DeleteVPCAssociationAuthorizationRequest indicates an expected call of DeleteVPCAssociationAuthorizationRequest. +func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorizationRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorizationRequest), arg0) +} + +// DeleteVPCAssociationAuthorizationWithContext mocks base method. +func (m *MockRoute53API) DeleteVPCAssociationAuthorizationWithContext(arg0 aws.Context, arg1 *route53.DeleteVPCAssociationAuthorizationInput, arg2 ...request.Option) (*route53.DeleteVPCAssociationAuthorizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorizationWithContext", varargs...) + ret0, _ := ret[0].(*route53.DeleteVPCAssociationAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVPCAssociationAuthorizationWithContext indicates an expected call of DeleteVPCAssociationAuthorizationWithContext. +func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorizationWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorizationWithContext), varargs...) +} + +// DisableHostedZoneDNSSEC mocks base method. +func (m *MockRoute53API) DisableHostedZoneDNSSEC(arg0 *route53.DisableHostedZoneDNSSECInput) (*route53.DisableHostedZoneDNSSECOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableHostedZoneDNSSEC", arg0) + ret0, _ := ret[0].(*route53.DisableHostedZoneDNSSECOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableHostedZoneDNSSEC indicates an expected call of DisableHostedZoneDNSSEC. +func (mr *MockRoute53APIMockRecorder) DisableHostedZoneDNSSEC(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableHostedZoneDNSSEC", reflect.TypeOf((*MockRoute53API)(nil).DisableHostedZoneDNSSEC), arg0) +} + +// DisableHostedZoneDNSSECRequest mocks base method. +func (m *MockRoute53API) DisableHostedZoneDNSSECRequest(arg0 *route53.DisableHostedZoneDNSSECInput) (*request.Request, *route53.DisableHostedZoneDNSSECOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableHostedZoneDNSSECRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DisableHostedZoneDNSSECOutput) + return ret0, ret1 +} + +// DisableHostedZoneDNSSECRequest indicates an expected call of DisableHostedZoneDNSSECRequest. +func (mr *MockRoute53APIMockRecorder) DisableHostedZoneDNSSECRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableHostedZoneDNSSECRequest", reflect.TypeOf((*MockRoute53API)(nil).DisableHostedZoneDNSSECRequest), arg0) +} + +// DisableHostedZoneDNSSECWithContext mocks base method. +func (m *MockRoute53API) DisableHostedZoneDNSSECWithContext(arg0 aws.Context, arg1 *route53.DisableHostedZoneDNSSECInput, arg2 ...request.Option) (*route53.DisableHostedZoneDNSSECOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableHostedZoneDNSSECWithContext", varargs...) + ret0, _ := ret[0].(*route53.DisableHostedZoneDNSSECOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableHostedZoneDNSSECWithContext indicates an expected call of DisableHostedZoneDNSSECWithContext. +func (mr *MockRoute53APIMockRecorder) DisableHostedZoneDNSSECWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableHostedZoneDNSSECWithContext", reflect.TypeOf((*MockRoute53API)(nil).DisableHostedZoneDNSSECWithContext), varargs...) +} + +// DisassociateVPCFromHostedZone mocks base method. +func (m *MockRoute53API) DisassociateVPCFromHostedZone(arg0 *route53.DisassociateVPCFromHostedZoneInput) (*route53.DisassociateVPCFromHostedZoneOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZone", arg0) + ret0, _ := ret[0].(*route53.DisassociateVPCFromHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateVPCFromHostedZone indicates an expected call of DisassociateVPCFromHostedZone. +func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZone(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZone", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZone), arg0) +} + +// DisassociateVPCFromHostedZoneRequest mocks base method. +func (m *MockRoute53API) DisassociateVPCFromHostedZoneRequest(arg0 *route53.DisassociateVPCFromHostedZoneInput) (*request.Request, *route53.DisassociateVPCFromHostedZoneOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZoneRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.DisassociateVPCFromHostedZoneOutput) + return ret0, ret1 +} + +// DisassociateVPCFromHostedZoneRequest indicates an expected call of DisassociateVPCFromHostedZoneRequest. +func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZoneRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZoneRequest), arg0) +} + +// DisassociateVPCFromHostedZoneWithContext mocks base method. +func (m *MockRoute53API) DisassociateVPCFromHostedZoneWithContext(arg0 aws.Context, arg1 *route53.DisassociateVPCFromHostedZoneInput, arg2 ...request.Option) (*route53.DisassociateVPCFromHostedZoneOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZoneWithContext", varargs...) + ret0, _ := ret[0].(*route53.DisassociateVPCFromHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateVPCFromHostedZoneWithContext indicates an expected call of DisassociateVPCFromHostedZoneWithContext. +func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZoneWithContext), varargs...) +} + +// EnableHostedZoneDNSSEC mocks base method. +func (m *MockRoute53API) EnableHostedZoneDNSSEC(arg0 *route53.EnableHostedZoneDNSSECInput) (*route53.EnableHostedZoneDNSSECOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableHostedZoneDNSSEC", arg0) + ret0, _ := ret[0].(*route53.EnableHostedZoneDNSSECOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableHostedZoneDNSSEC indicates an expected call of EnableHostedZoneDNSSEC. +func (mr *MockRoute53APIMockRecorder) EnableHostedZoneDNSSEC(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHostedZoneDNSSEC", reflect.TypeOf((*MockRoute53API)(nil).EnableHostedZoneDNSSEC), arg0) +} + +// EnableHostedZoneDNSSECRequest mocks base method. +func (m *MockRoute53API) EnableHostedZoneDNSSECRequest(arg0 *route53.EnableHostedZoneDNSSECInput) (*request.Request, *route53.EnableHostedZoneDNSSECOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableHostedZoneDNSSECRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.EnableHostedZoneDNSSECOutput) + return ret0, ret1 +} + +// EnableHostedZoneDNSSECRequest indicates an expected call of EnableHostedZoneDNSSECRequest. +func (mr *MockRoute53APIMockRecorder) EnableHostedZoneDNSSECRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHostedZoneDNSSECRequest", reflect.TypeOf((*MockRoute53API)(nil).EnableHostedZoneDNSSECRequest), arg0) +} + +// EnableHostedZoneDNSSECWithContext mocks base method. +func (m *MockRoute53API) EnableHostedZoneDNSSECWithContext(arg0 aws.Context, arg1 *route53.EnableHostedZoneDNSSECInput, arg2 ...request.Option) (*route53.EnableHostedZoneDNSSECOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableHostedZoneDNSSECWithContext", varargs...) + ret0, _ := ret[0].(*route53.EnableHostedZoneDNSSECOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableHostedZoneDNSSECWithContext indicates an expected call of EnableHostedZoneDNSSECWithContext. +func (mr *MockRoute53APIMockRecorder) EnableHostedZoneDNSSECWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHostedZoneDNSSECWithContext", reflect.TypeOf((*MockRoute53API)(nil).EnableHostedZoneDNSSECWithContext), varargs...) +} + +// GetAccountLimit mocks base method. +func (m *MockRoute53API) GetAccountLimit(arg0 *route53.GetAccountLimitInput) (*route53.GetAccountLimitOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountLimit", arg0) + ret0, _ := ret[0].(*route53.GetAccountLimitOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountLimit indicates an expected call of GetAccountLimit. +func (mr *MockRoute53APIMockRecorder) GetAccountLimit(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimit", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimit), arg0) +} + +// GetAccountLimitRequest mocks base method. +func (m *MockRoute53API) GetAccountLimitRequest(arg0 *route53.GetAccountLimitInput) (*request.Request, *route53.GetAccountLimitOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountLimitRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetAccountLimitOutput) + return ret0, ret1 +} + +// GetAccountLimitRequest indicates an expected call of GetAccountLimitRequest. +func (mr *MockRoute53APIMockRecorder) GetAccountLimitRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimitRequest), arg0) +} + +// GetAccountLimitWithContext mocks base method. +func (m *MockRoute53API) GetAccountLimitWithContext(arg0 aws.Context, arg1 *route53.GetAccountLimitInput, arg2 ...request.Option) (*route53.GetAccountLimitOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAccountLimitWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetAccountLimitOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountLimitWithContext indicates an expected call of GetAccountLimitWithContext. +func (mr *MockRoute53APIMockRecorder) GetAccountLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimitWithContext), varargs...) +} + +// GetChange mocks base method. +func (m *MockRoute53API) GetChange(arg0 *route53.GetChangeInput) (*route53.GetChangeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetChange", arg0) + ret0, _ := ret[0].(*route53.GetChangeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetChange indicates an expected call of GetChange. +func (mr *MockRoute53APIMockRecorder) GetChange(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChange", reflect.TypeOf((*MockRoute53API)(nil).GetChange), arg0) +} + +// GetChangeRequest mocks base method. +func (m *MockRoute53API) GetChangeRequest(arg0 *route53.GetChangeInput) (*request.Request, *route53.GetChangeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetChangeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetChangeOutput) + return ret0, ret1 +} + +// GetChangeRequest indicates an expected call of GetChangeRequest. +func (mr *MockRoute53APIMockRecorder) GetChangeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangeRequest", reflect.TypeOf((*MockRoute53API)(nil).GetChangeRequest), arg0) +} + +// GetChangeWithContext mocks base method. +func (m *MockRoute53API) GetChangeWithContext(arg0 aws.Context, arg1 *route53.GetChangeInput, arg2 ...request.Option) (*route53.GetChangeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetChangeWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetChangeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetChangeWithContext indicates an expected call of GetChangeWithContext. +func (mr *MockRoute53APIMockRecorder) GetChangeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangeWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetChangeWithContext), varargs...) +} + +// GetCheckerIpRanges mocks base method. +func (m *MockRoute53API) GetCheckerIpRanges(arg0 *route53.GetCheckerIpRangesInput) (*route53.GetCheckerIpRangesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCheckerIpRanges", arg0) + ret0, _ := ret[0].(*route53.GetCheckerIpRangesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCheckerIpRanges indicates an expected call of GetCheckerIpRanges. +func (mr *MockRoute53APIMockRecorder) GetCheckerIpRanges(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRanges", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRanges), arg0) +} + +// GetCheckerIpRangesRequest mocks base method. +func (m *MockRoute53API) GetCheckerIpRangesRequest(arg0 *route53.GetCheckerIpRangesInput) (*request.Request, *route53.GetCheckerIpRangesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCheckerIpRangesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetCheckerIpRangesOutput) + return ret0, ret1 +} + +// GetCheckerIpRangesRequest indicates an expected call of GetCheckerIpRangesRequest. +func (mr *MockRoute53APIMockRecorder) GetCheckerIpRangesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRangesRequest", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRangesRequest), arg0) +} + +// GetCheckerIpRangesWithContext mocks base method. +func (m *MockRoute53API) GetCheckerIpRangesWithContext(arg0 aws.Context, arg1 *route53.GetCheckerIpRangesInput, arg2 ...request.Option) (*route53.GetCheckerIpRangesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetCheckerIpRangesWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetCheckerIpRangesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCheckerIpRangesWithContext indicates an expected call of GetCheckerIpRangesWithContext. +func (mr *MockRoute53APIMockRecorder) GetCheckerIpRangesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRangesWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRangesWithContext), varargs...) +} + +// GetDNSSEC mocks base method. +func (m *MockRoute53API) GetDNSSEC(arg0 *route53.GetDNSSECInput) (*route53.GetDNSSECOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDNSSEC", arg0) + ret0, _ := ret[0].(*route53.GetDNSSECOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDNSSEC indicates an expected call of GetDNSSEC. +func (mr *MockRoute53APIMockRecorder) GetDNSSEC(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDNSSEC", reflect.TypeOf((*MockRoute53API)(nil).GetDNSSEC), arg0) +} + +// GetDNSSECRequest mocks base method. +func (m *MockRoute53API) GetDNSSECRequest(arg0 *route53.GetDNSSECInput) (*request.Request, *route53.GetDNSSECOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDNSSECRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetDNSSECOutput) + return ret0, ret1 +} + +// GetDNSSECRequest indicates an expected call of GetDNSSECRequest. +func (mr *MockRoute53APIMockRecorder) GetDNSSECRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDNSSECRequest", reflect.TypeOf((*MockRoute53API)(nil).GetDNSSECRequest), arg0) +} + +// GetDNSSECWithContext mocks base method. +func (m *MockRoute53API) GetDNSSECWithContext(arg0 aws.Context, arg1 *route53.GetDNSSECInput, arg2 ...request.Option) (*route53.GetDNSSECOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetDNSSECWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetDNSSECOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDNSSECWithContext indicates an expected call of GetDNSSECWithContext. +func (mr *MockRoute53APIMockRecorder) GetDNSSECWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDNSSECWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetDNSSECWithContext), varargs...) +} + +// GetGeoLocation mocks base method. +func (m *MockRoute53API) GetGeoLocation(arg0 *route53.GetGeoLocationInput) (*route53.GetGeoLocationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGeoLocation", arg0) + ret0, _ := ret[0].(*route53.GetGeoLocationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGeoLocation indicates an expected call of GetGeoLocation. +func (mr *MockRoute53APIMockRecorder) GetGeoLocation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocation", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocation), arg0) +} + +// GetGeoLocationRequest mocks base method. +func (m *MockRoute53API) GetGeoLocationRequest(arg0 *route53.GetGeoLocationInput) (*request.Request, *route53.GetGeoLocationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGeoLocationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetGeoLocationOutput) + return ret0, ret1 +} + +// GetGeoLocationRequest indicates an expected call of GetGeoLocationRequest. +func (mr *MockRoute53APIMockRecorder) GetGeoLocationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocationRequest", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocationRequest), arg0) +} + +// GetGeoLocationWithContext mocks base method. +func (m *MockRoute53API) GetGeoLocationWithContext(arg0 aws.Context, arg1 *route53.GetGeoLocationInput, arg2 ...request.Option) (*route53.GetGeoLocationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetGeoLocationWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetGeoLocationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGeoLocationWithContext indicates an expected call of GetGeoLocationWithContext. +func (mr *MockRoute53APIMockRecorder) GetGeoLocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocationWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocationWithContext), varargs...) +} + +// GetHealthCheck mocks base method. +func (m *MockRoute53API) GetHealthCheck(arg0 *route53.GetHealthCheckInput) (*route53.GetHealthCheckOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthCheck", arg0) + ret0, _ := ret[0].(*route53.GetHealthCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthCheck indicates an expected call of GetHealthCheck. +func (mr *MockRoute53APIMockRecorder) GetHealthCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheck), arg0) +} + +// GetHealthCheckCount mocks base method. +func (m *MockRoute53API) GetHealthCheckCount(arg0 *route53.GetHealthCheckCountInput) (*route53.GetHealthCheckCountOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthCheckCount", arg0) + ret0, _ := ret[0].(*route53.GetHealthCheckCountOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthCheckCount indicates an expected call of GetHealthCheckCount. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckCount(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCount", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCount), arg0) +} + +// GetHealthCheckCountRequest mocks base method. +func (m *MockRoute53API) GetHealthCheckCountRequest(arg0 *route53.GetHealthCheckCountInput) (*request.Request, *route53.GetHealthCheckCountOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthCheckCountRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetHealthCheckCountOutput) + return ret0, ret1 +} + +// GetHealthCheckCountRequest indicates an expected call of GetHealthCheckCountRequest. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckCountRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCountRequest), arg0) +} + +// GetHealthCheckCountWithContext mocks base method. +func (m *MockRoute53API) GetHealthCheckCountWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckCountInput, arg2 ...request.Option) (*route53.GetHealthCheckCountOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHealthCheckCountWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetHealthCheckCountOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthCheckCountWithContext indicates an expected call of GetHealthCheckCountWithContext. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCountWithContext), varargs...) +} + +// GetHealthCheckLastFailureReason mocks base method. +func (m *MockRoute53API) GetHealthCheckLastFailureReason(arg0 *route53.GetHealthCheckLastFailureReasonInput) (*route53.GetHealthCheckLastFailureReasonOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReason", arg0) + ret0, _ := ret[0].(*route53.GetHealthCheckLastFailureReasonOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthCheckLastFailureReason indicates an expected call of GetHealthCheckLastFailureReason. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReason(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReason", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReason), arg0) +} + +// GetHealthCheckLastFailureReasonRequest mocks base method. +func (m *MockRoute53API) GetHealthCheckLastFailureReasonRequest(arg0 *route53.GetHealthCheckLastFailureReasonInput) (*request.Request, *route53.GetHealthCheckLastFailureReasonOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReasonRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetHealthCheckLastFailureReasonOutput) + return ret0, ret1 +} + +// GetHealthCheckLastFailureReasonRequest indicates an expected call of GetHealthCheckLastFailureReasonRequest. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReasonRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReasonRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReasonRequest), arg0) +} + +// GetHealthCheckLastFailureReasonWithContext mocks base method. +func (m *MockRoute53API) GetHealthCheckLastFailureReasonWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckLastFailureReasonInput, arg2 ...request.Option) (*route53.GetHealthCheckLastFailureReasonOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReasonWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetHealthCheckLastFailureReasonOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthCheckLastFailureReasonWithContext indicates an expected call of GetHealthCheckLastFailureReasonWithContext. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReasonWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReasonWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReasonWithContext), varargs...) +} + +// GetHealthCheckRequest mocks base method. +func (m *MockRoute53API) GetHealthCheckRequest(arg0 *route53.GetHealthCheckInput) (*request.Request, *route53.GetHealthCheckOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthCheckRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetHealthCheckOutput) + return ret0, ret1 +} + +// GetHealthCheckRequest indicates an expected call of GetHealthCheckRequest. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckRequest), arg0) +} + +// GetHealthCheckStatus mocks base method. +func (m *MockRoute53API) GetHealthCheckStatus(arg0 *route53.GetHealthCheckStatusInput) (*route53.GetHealthCheckStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthCheckStatus", arg0) + ret0, _ := ret[0].(*route53.GetHealthCheckStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthCheckStatus indicates an expected call of GetHealthCheckStatus. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatus", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatus), arg0) +} + +// GetHealthCheckStatusRequest mocks base method. +func (m *MockRoute53API) GetHealthCheckStatusRequest(arg0 *route53.GetHealthCheckStatusInput) (*request.Request, *route53.GetHealthCheckStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthCheckStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetHealthCheckStatusOutput) + return ret0, ret1 +} + +// GetHealthCheckStatusRequest indicates an expected call of GetHealthCheckStatusRequest. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatusRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatusRequest), arg0) +} + +// GetHealthCheckStatusWithContext mocks base method. +func (m *MockRoute53API) GetHealthCheckStatusWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckStatusInput, arg2 ...request.Option) (*route53.GetHealthCheckStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHealthCheckStatusWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetHealthCheckStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthCheckStatusWithContext indicates an expected call of GetHealthCheckStatusWithContext. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatusWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatusWithContext), varargs...) +} + +// GetHealthCheckWithContext mocks base method. +func (m *MockRoute53API) GetHealthCheckWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckInput, arg2 ...request.Option) (*route53.GetHealthCheckOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHealthCheckWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetHealthCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthCheckWithContext indicates an expected call of GetHealthCheckWithContext. +func (mr *MockRoute53APIMockRecorder) GetHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckWithContext), varargs...) +} + +// GetHostedZone mocks base method. +func (m *MockRoute53API) GetHostedZone(arg0 *route53.GetHostedZoneInput) (*route53.GetHostedZoneOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostedZone", arg0) + ret0, _ := ret[0].(*route53.GetHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostedZone indicates an expected call of GetHostedZone. +func (mr *MockRoute53APIMockRecorder) GetHostedZone(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZone", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZone), arg0) +} + +// GetHostedZoneCount mocks base method. +func (m *MockRoute53API) GetHostedZoneCount(arg0 *route53.GetHostedZoneCountInput) (*route53.GetHostedZoneCountOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostedZoneCount", arg0) + ret0, _ := ret[0].(*route53.GetHostedZoneCountOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostedZoneCount indicates an expected call of GetHostedZoneCount. +func (mr *MockRoute53APIMockRecorder) GetHostedZoneCount(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCount", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCount), arg0) +} + +// GetHostedZoneCountRequest mocks base method. +func (m *MockRoute53API) GetHostedZoneCountRequest(arg0 *route53.GetHostedZoneCountInput) (*request.Request, *route53.GetHostedZoneCountOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostedZoneCountRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetHostedZoneCountOutput) + return ret0, ret1 +} + +// GetHostedZoneCountRequest indicates an expected call of GetHostedZoneCountRequest. +func (mr *MockRoute53APIMockRecorder) GetHostedZoneCountRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCountRequest), arg0) +} + +// GetHostedZoneCountWithContext mocks base method. +func (m *MockRoute53API) GetHostedZoneCountWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneCountInput, arg2 ...request.Option) (*route53.GetHostedZoneCountOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHostedZoneCountWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetHostedZoneCountOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostedZoneCountWithContext indicates an expected call of GetHostedZoneCountWithContext. +func (mr *MockRoute53APIMockRecorder) GetHostedZoneCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCountWithContext), varargs...) +} + +// GetHostedZoneLimit mocks base method. +func (m *MockRoute53API) GetHostedZoneLimit(arg0 *route53.GetHostedZoneLimitInput) (*route53.GetHostedZoneLimitOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostedZoneLimit", arg0) + ret0, _ := ret[0].(*route53.GetHostedZoneLimitOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostedZoneLimit indicates an expected call of GetHostedZoneLimit. +func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimit(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimit", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimit), arg0) +} + +// GetHostedZoneLimitRequest mocks base method. +func (m *MockRoute53API) GetHostedZoneLimitRequest(arg0 *route53.GetHostedZoneLimitInput) (*request.Request, *route53.GetHostedZoneLimitOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostedZoneLimitRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetHostedZoneLimitOutput) + return ret0, ret1 +} + +// GetHostedZoneLimitRequest indicates an expected call of GetHostedZoneLimitRequest. +func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimitRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimitRequest), arg0) +} + +// GetHostedZoneLimitWithContext mocks base method. +func (m *MockRoute53API) GetHostedZoneLimitWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneLimitInput, arg2 ...request.Option) (*route53.GetHostedZoneLimitOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHostedZoneLimitWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetHostedZoneLimitOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostedZoneLimitWithContext indicates an expected call of GetHostedZoneLimitWithContext. +func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimitWithContext), varargs...) +} + +// GetHostedZoneRequest mocks base method. +func (m *MockRoute53API) GetHostedZoneRequest(arg0 *route53.GetHostedZoneInput) (*request.Request, *route53.GetHostedZoneOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostedZoneRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetHostedZoneOutput) + return ret0, ret1 +} + +// GetHostedZoneRequest indicates an expected call of GetHostedZoneRequest. +func (mr *MockRoute53APIMockRecorder) GetHostedZoneRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneRequest), arg0) +} + +// GetHostedZoneWithContext mocks base method. +func (m *MockRoute53API) GetHostedZoneWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneInput, arg2 ...request.Option) (*route53.GetHostedZoneOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHostedZoneWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostedZoneWithContext indicates an expected call of GetHostedZoneWithContext. +func (mr *MockRoute53APIMockRecorder) GetHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneWithContext), varargs...) +} + +// GetQueryLoggingConfig mocks base method. +func (m *MockRoute53API) GetQueryLoggingConfig(arg0 *route53.GetQueryLoggingConfigInput) (*route53.GetQueryLoggingConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryLoggingConfig", arg0) + ret0, _ := ret[0].(*route53.GetQueryLoggingConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueryLoggingConfig indicates an expected call of GetQueryLoggingConfig. +func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfig), arg0) +} + +// GetQueryLoggingConfigRequest mocks base method. +func (m *MockRoute53API) GetQueryLoggingConfigRequest(arg0 *route53.GetQueryLoggingConfigInput) (*request.Request, *route53.GetQueryLoggingConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryLoggingConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetQueryLoggingConfigOutput) + return ret0, ret1 +} + +// GetQueryLoggingConfigRequest indicates an expected call of GetQueryLoggingConfigRequest. +func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfigRequest), arg0) +} + +// GetQueryLoggingConfigWithContext mocks base method. +func (m *MockRoute53API) GetQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.GetQueryLoggingConfigInput, arg2 ...request.Option) (*route53.GetQueryLoggingConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetQueryLoggingConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetQueryLoggingConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueryLoggingConfigWithContext indicates an expected call of GetQueryLoggingConfigWithContext. +func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfigWithContext), varargs...) +} + +// GetReusableDelegationSet mocks base method. +func (m *MockRoute53API) GetReusableDelegationSet(arg0 *route53.GetReusableDelegationSetInput) (*route53.GetReusableDelegationSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReusableDelegationSet", arg0) + ret0, _ := ret[0].(*route53.GetReusableDelegationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetReusableDelegationSet indicates an expected call of GetReusableDelegationSet. +func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSet), arg0) +} + +// GetReusableDelegationSetLimit mocks base method. +func (m *MockRoute53API) GetReusableDelegationSetLimit(arg0 *route53.GetReusableDelegationSetLimitInput) (*route53.GetReusableDelegationSetLimitOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReusableDelegationSetLimit", arg0) + ret0, _ := ret[0].(*route53.GetReusableDelegationSetLimitOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetReusableDelegationSetLimit indicates an expected call of GetReusableDelegationSetLimit. +func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimit(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimit", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimit), arg0) +} + +// GetReusableDelegationSetLimitRequest mocks base method. +func (m *MockRoute53API) GetReusableDelegationSetLimitRequest(arg0 *route53.GetReusableDelegationSetLimitInput) (*request.Request, *route53.GetReusableDelegationSetLimitOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReusableDelegationSetLimitRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetReusableDelegationSetLimitOutput) + return ret0, ret1 +} + +// GetReusableDelegationSetLimitRequest indicates an expected call of GetReusableDelegationSetLimitRequest. +func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimitRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimitRequest), arg0) +} + +// GetReusableDelegationSetLimitWithContext mocks base method. +func (m *MockRoute53API) GetReusableDelegationSetLimitWithContext(arg0 aws.Context, arg1 *route53.GetReusableDelegationSetLimitInput, arg2 ...request.Option) (*route53.GetReusableDelegationSetLimitOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetReusableDelegationSetLimitWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetReusableDelegationSetLimitOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetReusableDelegationSetLimitWithContext indicates an expected call of GetReusableDelegationSetLimitWithContext. +func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimitWithContext), varargs...) +} + +// GetReusableDelegationSetRequest mocks base method. +func (m *MockRoute53API) GetReusableDelegationSetRequest(arg0 *route53.GetReusableDelegationSetInput) (*request.Request, *route53.GetReusableDelegationSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReusableDelegationSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetReusableDelegationSetOutput) + return ret0, ret1 +} + +// GetReusableDelegationSetRequest indicates an expected call of GetReusableDelegationSetRequest. +func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetRequest), arg0) +} + +// GetReusableDelegationSetWithContext mocks base method. +func (m *MockRoute53API) GetReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.GetReusableDelegationSetInput, arg2 ...request.Option) (*route53.GetReusableDelegationSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetReusableDelegationSetWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetReusableDelegationSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetReusableDelegationSetWithContext indicates an expected call of GetReusableDelegationSetWithContext. +func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetWithContext), varargs...) +} + +// GetTrafficPolicy mocks base method. +func (m *MockRoute53API) GetTrafficPolicy(arg0 *route53.GetTrafficPolicyInput) (*route53.GetTrafficPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrafficPolicy", arg0) + ret0, _ := ret[0].(*route53.GetTrafficPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrafficPolicy indicates an expected call of GetTrafficPolicy. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicy), arg0) +} + +// GetTrafficPolicyInstance mocks base method. +func (m *MockRoute53API) GetTrafficPolicyInstance(arg0 *route53.GetTrafficPolicyInstanceInput) (*route53.GetTrafficPolicyInstanceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrafficPolicyInstance", arg0) + ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrafficPolicyInstance indicates an expected call of GetTrafficPolicyInstance. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstance), arg0) +} + +// GetTrafficPolicyInstanceCount mocks base method. +func (m *MockRoute53API) GetTrafficPolicyInstanceCount(arg0 *route53.GetTrafficPolicyInstanceCountInput) (*route53.GetTrafficPolicyInstanceCountOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCount", arg0) + ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceCountOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrafficPolicyInstanceCount indicates an expected call of GetTrafficPolicyInstanceCount. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCount(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCount", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCount), arg0) +} + +// GetTrafficPolicyInstanceCountRequest mocks base method. +func (m *MockRoute53API) GetTrafficPolicyInstanceCountRequest(arg0 *route53.GetTrafficPolicyInstanceCountInput) (*request.Request, *route53.GetTrafficPolicyInstanceCountOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCountRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetTrafficPolicyInstanceCountOutput) + return ret0, ret1 +} + +// GetTrafficPolicyInstanceCountRequest indicates an expected call of GetTrafficPolicyInstanceCountRequest. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCountRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCountRequest), arg0) +} + +// GetTrafficPolicyInstanceCountWithContext mocks base method. +func (m *MockRoute53API) GetTrafficPolicyInstanceCountWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInstanceCountInput, arg2 ...request.Option) (*route53.GetTrafficPolicyInstanceCountOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCountWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceCountOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrafficPolicyInstanceCountWithContext indicates an expected call of GetTrafficPolicyInstanceCountWithContext. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCountWithContext), varargs...) +} + +// GetTrafficPolicyInstanceRequest mocks base method. +func (m *MockRoute53API) GetTrafficPolicyInstanceRequest(arg0 *route53.GetTrafficPolicyInstanceInput) (*request.Request, *route53.GetTrafficPolicyInstanceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetTrafficPolicyInstanceOutput) + return ret0, ret1 +} + +// GetTrafficPolicyInstanceRequest indicates an expected call of GetTrafficPolicyInstanceRequest. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceRequest), arg0) +} + +// GetTrafficPolicyInstanceWithContext mocks base method. +func (m *MockRoute53API) GetTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.GetTrafficPolicyInstanceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrafficPolicyInstanceWithContext indicates an expected call of GetTrafficPolicyInstanceWithContext. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceWithContext), varargs...) +} + +// GetTrafficPolicyRequest mocks base method. +func (m *MockRoute53API) GetTrafficPolicyRequest(arg0 *route53.GetTrafficPolicyInput) (*request.Request, *route53.GetTrafficPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrafficPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.GetTrafficPolicyOutput) + return ret0, ret1 +} + +// GetTrafficPolicyRequest indicates an expected call of GetTrafficPolicyRequest. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyRequest), arg0) +} + +// GetTrafficPolicyWithContext mocks base method. +func (m *MockRoute53API) GetTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInput, arg2 ...request.Option) (*route53.GetTrafficPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTrafficPolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53.GetTrafficPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrafficPolicyWithContext indicates an expected call of GetTrafficPolicyWithContext. +func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyWithContext), varargs...) +} + +// ListCidrBlocks mocks base method. +func (m *MockRoute53API) ListCidrBlocks(arg0 *route53.ListCidrBlocksInput) (*route53.ListCidrBlocksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrBlocks", arg0) + ret0, _ := ret[0].(*route53.ListCidrBlocksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCidrBlocks indicates an expected call of ListCidrBlocks. +func (mr *MockRoute53APIMockRecorder) ListCidrBlocks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrBlocks", reflect.TypeOf((*MockRoute53API)(nil).ListCidrBlocks), arg0) +} + +// ListCidrBlocksPages mocks base method. +func (m *MockRoute53API) ListCidrBlocksPages(arg0 *route53.ListCidrBlocksInput, arg1 func(*route53.ListCidrBlocksOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrBlocksPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListCidrBlocksPages indicates an expected call of ListCidrBlocksPages. +func (mr *MockRoute53APIMockRecorder) ListCidrBlocksPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrBlocksPages", reflect.TypeOf((*MockRoute53API)(nil).ListCidrBlocksPages), arg0, arg1) +} + +// ListCidrBlocksPagesWithContext mocks base method. +func (m *MockRoute53API) ListCidrBlocksPagesWithContext(arg0 aws.Context, arg1 *route53.ListCidrBlocksInput, arg2 func(*route53.ListCidrBlocksOutput, 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, "ListCidrBlocksPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListCidrBlocksPagesWithContext indicates an expected call of ListCidrBlocksPagesWithContext. +func (mr *MockRoute53APIMockRecorder) ListCidrBlocksPagesWithContext(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, "ListCidrBlocksPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListCidrBlocksPagesWithContext), varargs...) +} + +// ListCidrBlocksRequest mocks base method. +func (m *MockRoute53API) ListCidrBlocksRequest(arg0 *route53.ListCidrBlocksInput) (*request.Request, *route53.ListCidrBlocksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrBlocksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListCidrBlocksOutput) + return ret0, ret1 +} + +// ListCidrBlocksRequest indicates an expected call of ListCidrBlocksRequest. +func (mr *MockRoute53APIMockRecorder) ListCidrBlocksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrBlocksRequest", reflect.TypeOf((*MockRoute53API)(nil).ListCidrBlocksRequest), arg0) +} + +// ListCidrBlocksWithContext mocks base method. +func (m *MockRoute53API) ListCidrBlocksWithContext(arg0 aws.Context, arg1 *route53.ListCidrBlocksInput, arg2 ...request.Option) (*route53.ListCidrBlocksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCidrBlocksWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListCidrBlocksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCidrBlocksWithContext indicates an expected call of ListCidrBlocksWithContext. +func (mr *MockRoute53APIMockRecorder) ListCidrBlocksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrBlocksWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListCidrBlocksWithContext), varargs...) +} + +// ListCidrCollections mocks base method. +func (m *MockRoute53API) ListCidrCollections(arg0 *route53.ListCidrCollectionsInput) (*route53.ListCidrCollectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrCollections", arg0) + ret0, _ := ret[0].(*route53.ListCidrCollectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCidrCollections indicates an expected call of ListCidrCollections. +func (mr *MockRoute53APIMockRecorder) ListCidrCollections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrCollections", reflect.TypeOf((*MockRoute53API)(nil).ListCidrCollections), arg0) +} + +// ListCidrCollectionsPages mocks base method. +func (m *MockRoute53API) ListCidrCollectionsPages(arg0 *route53.ListCidrCollectionsInput, arg1 func(*route53.ListCidrCollectionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrCollectionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListCidrCollectionsPages indicates an expected call of ListCidrCollectionsPages. +func (mr *MockRoute53APIMockRecorder) ListCidrCollectionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrCollectionsPages", reflect.TypeOf((*MockRoute53API)(nil).ListCidrCollectionsPages), arg0, arg1) +} + +// ListCidrCollectionsPagesWithContext mocks base method. +func (m *MockRoute53API) ListCidrCollectionsPagesWithContext(arg0 aws.Context, arg1 *route53.ListCidrCollectionsInput, arg2 func(*route53.ListCidrCollectionsOutput, 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, "ListCidrCollectionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListCidrCollectionsPagesWithContext indicates an expected call of ListCidrCollectionsPagesWithContext. +func (mr *MockRoute53APIMockRecorder) ListCidrCollectionsPagesWithContext(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, "ListCidrCollectionsPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListCidrCollectionsPagesWithContext), varargs...) +} + +// ListCidrCollectionsRequest mocks base method. +func (m *MockRoute53API) ListCidrCollectionsRequest(arg0 *route53.ListCidrCollectionsInput) (*request.Request, *route53.ListCidrCollectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrCollectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListCidrCollectionsOutput) + return ret0, ret1 +} + +// ListCidrCollectionsRequest indicates an expected call of ListCidrCollectionsRequest. +func (mr *MockRoute53APIMockRecorder) ListCidrCollectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrCollectionsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListCidrCollectionsRequest), arg0) +} + +// ListCidrCollectionsWithContext mocks base method. +func (m *MockRoute53API) ListCidrCollectionsWithContext(arg0 aws.Context, arg1 *route53.ListCidrCollectionsInput, arg2 ...request.Option) (*route53.ListCidrCollectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCidrCollectionsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListCidrCollectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCidrCollectionsWithContext indicates an expected call of ListCidrCollectionsWithContext. +func (mr *MockRoute53APIMockRecorder) ListCidrCollectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrCollectionsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListCidrCollectionsWithContext), varargs...) +} + +// ListCidrLocations mocks base method. +func (m *MockRoute53API) ListCidrLocations(arg0 *route53.ListCidrLocationsInput) (*route53.ListCidrLocationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrLocations", arg0) + ret0, _ := ret[0].(*route53.ListCidrLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCidrLocations indicates an expected call of ListCidrLocations. +func (mr *MockRoute53APIMockRecorder) ListCidrLocations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrLocations", reflect.TypeOf((*MockRoute53API)(nil).ListCidrLocations), arg0) +} + +// ListCidrLocationsPages mocks base method. +func (m *MockRoute53API) ListCidrLocationsPages(arg0 *route53.ListCidrLocationsInput, arg1 func(*route53.ListCidrLocationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrLocationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListCidrLocationsPages indicates an expected call of ListCidrLocationsPages. +func (mr *MockRoute53APIMockRecorder) ListCidrLocationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrLocationsPages", reflect.TypeOf((*MockRoute53API)(nil).ListCidrLocationsPages), arg0, arg1) +} + +// ListCidrLocationsPagesWithContext mocks base method. +func (m *MockRoute53API) ListCidrLocationsPagesWithContext(arg0 aws.Context, arg1 *route53.ListCidrLocationsInput, arg2 func(*route53.ListCidrLocationsOutput, 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, "ListCidrLocationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListCidrLocationsPagesWithContext indicates an expected call of ListCidrLocationsPagesWithContext. +func (mr *MockRoute53APIMockRecorder) ListCidrLocationsPagesWithContext(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, "ListCidrLocationsPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListCidrLocationsPagesWithContext), varargs...) +} + +// ListCidrLocationsRequest mocks base method. +func (m *MockRoute53API) ListCidrLocationsRequest(arg0 *route53.ListCidrLocationsInput) (*request.Request, *route53.ListCidrLocationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCidrLocationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListCidrLocationsOutput) + return ret0, ret1 +} + +// ListCidrLocationsRequest indicates an expected call of ListCidrLocationsRequest. +func (mr *MockRoute53APIMockRecorder) ListCidrLocationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrLocationsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListCidrLocationsRequest), arg0) +} + +// ListCidrLocationsWithContext mocks base method. +func (m *MockRoute53API) ListCidrLocationsWithContext(arg0 aws.Context, arg1 *route53.ListCidrLocationsInput, arg2 ...request.Option) (*route53.ListCidrLocationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListCidrLocationsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListCidrLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCidrLocationsWithContext indicates an expected call of ListCidrLocationsWithContext. +func (mr *MockRoute53APIMockRecorder) ListCidrLocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCidrLocationsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListCidrLocationsWithContext), varargs...) +} + +// ListGeoLocations mocks base method. +func (m *MockRoute53API) ListGeoLocations(arg0 *route53.ListGeoLocationsInput) (*route53.ListGeoLocationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGeoLocations", arg0) + ret0, _ := ret[0].(*route53.ListGeoLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGeoLocations indicates an expected call of ListGeoLocations. +func (mr *MockRoute53APIMockRecorder) ListGeoLocations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocations", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocations), arg0) +} + +// ListGeoLocationsRequest mocks base method. +func (m *MockRoute53API) ListGeoLocationsRequest(arg0 *route53.ListGeoLocationsInput) (*request.Request, *route53.ListGeoLocationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGeoLocationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListGeoLocationsOutput) + return ret0, ret1 +} + +// ListGeoLocationsRequest indicates an expected call of ListGeoLocationsRequest. +func (mr *MockRoute53APIMockRecorder) ListGeoLocationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocationsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocationsRequest), arg0) +} + +// ListGeoLocationsWithContext mocks base method. +func (m *MockRoute53API) ListGeoLocationsWithContext(arg0 aws.Context, arg1 *route53.ListGeoLocationsInput, arg2 ...request.Option) (*route53.ListGeoLocationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGeoLocationsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListGeoLocationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGeoLocationsWithContext indicates an expected call of ListGeoLocationsWithContext. +func (mr *MockRoute53APIMockRecorder) ListGeoLocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocationsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocationsWithContext), varargs...) +} + +// ListHealthChecks mocks base method. +func (m *MockRoute53API) ListHealthChecks(arg0 *route53.ListHealthChecksInput) (*route53.ListHealthChecksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHealthChecks", arg0) + ret0, _ := ret[0].(*route53.ListHealthChecksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListHealthChecks indicates an expected call of ListHealthChecks. +func (mr *MockRoute53APIMockRecorder) ListHealthChecks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecks", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecks), arg0) +} + +// ListHealthChecksPages mocks base method. +func (m *MockRoute53API) ListHealthChecksPages(arg0 *route53.ListHealthChecksInput, arg1 func(*route53.ListHealthChecksOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHealthChecksPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListHealthChecksPages indicates an expected call of ListHealthChecksPages. +func (mr *MockRoute53APIMockRecorder) ListHealthChecksPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksPages", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksPages), arg0, arg1) +} + +// ListHealthChecksPagesWithContext mocks base method. +func (m *MockRoute53API) ListHealthChecksPagesWithContext(arg0 aws.Context, arg1 *route53.ListHealthChecksInput, arg2 func(*route53.ListHealthChecksOutput, 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, "ListHealthChecksPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListHealthChecksPagesWithContext indicates an expected call of ListHealthChecksPagesWithContext. +func (mr *MockRoute53APIMockRecorder) ListHealthChecksPagesWithContext(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, "ListHealthChecksPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksPagesWithContext), varargs...) +} + +// ListHealthChecksRequest mocks base method. +func (m *MockRoute53API) ListHealthChecksRequest(arg0 *route53.ListHealthChecksInput) (*request.Request, *route53.ListHealthChecksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHealthChecksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListHealthChecksOutput) + return ret0, ret1 +} + +// ListHealthChecksRequest indicates an expected call of ListHealthChecksRequest. +func (mr *MockRoute53APIMockRecorder) ListHealthChecksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksRequest), arg0) +} + +// ListHealthChecksWithContext mocks base method. +func (m *MockRoute53API) ListHealthChecksWithContext(arg0 aws.Context, arg1 *route53.ListHealthChecksInput, arg2 ...request.Option) (*route53.ListHealthChecksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListHealthChecksWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListHealthChecksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListHealthChecksWithContext indicates an expected call of ListHealthChecksWithContext. +func (mr *MockRoute53APIMockRecorder) ListHealthChecksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksWithContext), varargs...) +} + +// ListHostedZones mocks base method. +func (m *MockRoute53API) ListHostedZones(arg0 *route53.ListHostedZonesInput) (*route53.ListHostedZonesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHostedZones", arg0) + ret0, _ := ret[0].(*route53.ListHostedZonesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListHostedZones indicates an expected call of ListHostedZones. +func (mr *MockRoute53APIMockRecorder) ListHostedZones(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZones", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZones), arg0) +} + +// ListHostedZonesByName mocks base method. +func (m *MockRoute53API) ListHostedZonesByName(arg0 *route53.ListHostedZonesByNameInput) (*route53.ListHostedZonesByNameOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHostedZonesByName", arg0) + ret0, _ := ret[0].(*route53.ListHostedZonesByNameOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListHostedZonesByName indicates an expected call of ListHostedZonesByName. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesByName(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByName", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByName), arg0) +} + +// ListHostedZonesByNameRequest mocks base method. +func (m *MockRoute53API) ListHostedZonesByNameRequest(arg0 *route53.ListHostedZonesByNameInput) (*request.Request, *route53.ListHostedZonesByNameOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHostedZonesByNameRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListHostedZonesByNameOutput) + return ret0, ret1 +} + +// ListHostedZonesByNameRequest indicates an expected call of ListHostedZonesByNameRequest. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesByNameRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByNameRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByNameRequest), arg0) +} + +// ListHostedZonesByNameWithContext mocks base method. +func (m *MockRoute53API) ListHostedZonesByNameWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesByNameInput, arg2 ...request.Option) (*route53.ListHostedZonesByNameOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListHostedZonesByNameWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListHostedZonesByNameOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListHostedZonesByNameWithContext indicates an expected call of ListHostedZonesByNameWithContext. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesByNameWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByNameWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByNameWithContext), varargs...) +} + +// ListHostedZonesByVPC mocks base method. +func (m *MockRoute53API) ListHostedZonesByVPC(arg0 *route53.ListHostedZonesByVPCInput) (*route53.ListHostedZonesByVPCOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHostedZonesByVPC", arg0) + ret0, _ := ret[0].(*route53.ListHostedZonesByVPCOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListHostedZonesByVPC indicates an expected call of ListHostedZonesByVPC. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesByVPC(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByVPC", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByVPC), arg0) +} + +// ListHostedZonesByVPCRequest mocks base method. +func (m *MockRoute53API) ListHostedZonesByVPCRequest(arg0 *route53.ListHostedZonesByVPCInput) (*request.Request, *route53.ListHostedZonesByVPCOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHostedZonesByVPCRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListHostedZonesByVPCOutput) + return ret0, ret1 +} + +// ListHostedZonesByVPCRequest indicates an expected call of ListHostedZonesByVPCRequest. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesByVPCRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByVPCRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByVPCRequest), arg0) +} + +// ListHostedZonesByVPCWithContext mocks base method. +func (m *MockRoute53API) ListHostedZonesByVPCWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesByVPCInput, arg2 ...request.Option) (*route53.ListHostedZonesByVPCOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListHostedZonesByVPCWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListHostedZonesByVPCOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListHostedZonesByVPCWithContext indicates an expected call of ListHostedZonesByVPCWithContext. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesByVPCWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByVPCWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByVPCWithContext), varargs...) +} + +// ListHostedZonesPages mocks base method. +func (m *MockRoute53API) ListHostedZonesPages(arg0 *route53.ListHostedZonesInput, arg1 func(*route53.ListHostedZonesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHostedZonesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListHostedZonesPages indicates an expected call of ListHostedZonesPages. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesPages", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesPages), arg0, arg1) +} + +// ListHostedZonesPagesWithContext mocks base method. +func (m *MockRoute53API) ListHostedZonesPagesWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesInput, arg2 func(*route53.ListHostedZonesOutput, 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, "ListHostedZonesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListHostedZonesPagesWithContext indicates an expected call of ListHostedZonesPagesWithContext. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesPagesWithContext(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, "ListHostedZonesPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesPagesWithContext), varargs...) +} + +// ListHostedZonesRequest mocks base method. +func (m *MockRoute53API) ListHostedZonesRequest(arg0 *route53.ListHostedZonesInput) (*request.Request, *route53.ListHostedZonesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListHostedZonesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListHostedZonesOutput) + return ret0, ret1 +} + +// ListHostedZonesRequest indicates an expected call of ListHostedZonesRequest. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesRequest), arg0) +} + +// ListHostedZonesWithContext mocks base method. +func (m *MockRoute53API) ListHostedZonesWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesInput, arg2 ...request.Option) (*route53.ListHostedZonesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListHostedZonesWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListHostedZonesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListHostedZonesWithContext indicates an expected call of ListHostedZonesWithContext. +func (mr *MockRoute53APIMockRecorder) ListHostedZonesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesWithContext), varargs...) +} + +// ListQueryLoggingConfigs mocks base method. +func (m *MockRoute53API) ListQueryLoggingConfigs(arg0 *route53.ListQueryLoggingConfigsInput) (*route53.ListQueryLoggingConfigsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListQueryLoggingConfigs", arg0) + ret0, _ := ret[0].(*route53.ListQueryLoggingConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListQueryLoggingConfigs indicates an expected call of ListQueryLoggingConfigs. +func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigs", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigs), arg0) +} + +// ListQueryLoggingConfigsPages mocks base method. +func (m *MockRoute53API) ListQueryLoggingConfigsPages(arg0 *route53.ListQueryLoggingConfigsInput, arg1 func(*route53.ListQueryLoggingConfigsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListQueryLoggingConfigsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListQueryLoggingConfigsPages indicates an expected call of ListQueryLoggingConfigsPages. +func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigsPages", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigsPages), arg0, arg1) +} + +// ListQueryLoggingConfigsPagesWithContext mocks base method. +func (m *MockRoute53API) ListQueryLoggingConfigsPagesWithContext(arg0 aws.Context, arg1 *route53.ListQueryLoggingConfigsInput, arg2 func(*route53.ListQueryLoggingConfigsOutput, 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, "ListQueryLoggingConfigsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListQueryLoggingConfigsPagesWithContext indicates an expected call of ListQueryLoggingConfigsPagesWithContext. +func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigsPagesWithContext(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, "ListQueryLoggingConfigsPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigsPagesWithContext), varargs...) +} + +// ListQueryLoggingConfigsRequest mocks base method. +func (m *MockRoute53API) ListQueryLoggingConfigsRequest(arg0 *route53.ListQueryLoggingConfigsInput) (*request.Request, *route53.ListQueryLoggingConfigsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListQueryLoggingConfigsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListQueryLoggingConfigsOutput) + return ret0, ret1 +} + +// ListQueryLoggingConfigsRequest indicates an expected call of ListQueryLoggingConfigsRequest. +func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigsRequest), arg0) +} + +// ListQueryLoggingConfigsWithContext mocks base method. +func (m *MockRoute53API) ListQueryLoggingConfigsWithContext(arg0 aws.Context, arg1 *route53.ListQueryLoggingConfigsInput, arg2 ...request.Option) (*route53.ListQueryLoggingConfigsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListQueryLoggingConfigsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListQueryLoggingConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListQueryLoggingConfigsWithContext indicates an expected call of ListQueryLoggingConfigsWithContext. +func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigsWithContext), varargs...) +} + +// ListResourceRecordSets mocks base method. +func (m *MockRoute53API) ListResourceRecordSets(arg0 *route53.ListResourceRecordSetsInput) (*route53.ListResourceRecordSetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResourceRecordSets", arg0) + ret0, _ := ret[0].(*route53.ListResourceRecordSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResourceRecordSets indicates an expected call of ListResourceRecordSets. +func (mr *MockRoute53APIMockRecorder) ListResourceRecordSets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSets", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSets), arg0) +} + +// ListResourceRecordSetsPages mocks base method. +func (m *MockRoute53API) ListResourceRecordSetsPages(arg0 *route53.ListResourceRecordSetsInput, arg1 func(*route53.ListResourceRecordSetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResourceRecordSetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResourceRecordSetsPages indicates an expected call of ListResourceRecordSetsPages. +func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsPages", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsPages), arg0, arg1) +} + +// ListResourceRecordSetsPagesWithContext mocks base method. +func (m *MockRoute53API) ListResourceRecordSetsPagesWithContext(arg0 aws.Context, arg1 *route53.ListResourceRecordSetsInput, arg2 func(*route53.ListResourceRecordSetsOutput, 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, "ListResourceRecordSetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResourceRecordSetsPagesWithContext indicates an expected call of ListResourceRecordSetsPagesWithContext. +func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsPagesWithContext(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, "ListResourceRecordSetsPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsPagesWithContext), varargs...) +} + +// ListResourceRecordSetsRequest mocks base method. +func (m *MockRoute53API) ListResourceRecordSetsRequest(arg0 *route53.ListResourceRecordSetsInput) (*request.Request, *route53.ListResourceRecordSetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResourceRecordSetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListResourceRecordSetsOutput) + return ret0, ret1 +} + +// ListResourceRecordSetsRequest indicates an expected call of ListResourceRecordSetsRequest. +func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsRequest), arg0) +} + +// ListResourceRecordSetsWithContext mocks base method. +func (m *MockRoute53API) ListResourceRecordSetsWithContext(arg0 aws.Context, arg1 *route53.ListResourceRecordSetsInput, arg2 ...request.Option) (*route53.ListResourceRecordSetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResourceRecordSetsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListResourceRecordSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResourceRecordSetsWithContext indicates an expected call of ListResourceRecordSetsWithContext. +func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsWithContext), varargs...) +} + +// ListReusableDelegationSets mocks base method. +func (m *MockRoute53API) ListReusableDelegationSets(arg0 *route53.ListReusableDelegationSetsInput) (*route53.ListReusableDelegationSetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListReusableDelegationSets", arg0) + ret0, _ := ret[0].(*route53.ListReusableDelegationSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListReusableDelegationSets indicates an expected call of ListReusableDelegationSets. +func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSets", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSets), arg0) +} + +// ListReusableDelegationSetsRequest mocks base method. +func (m *MockRoute53API) ListReusableDelegationSetsRequest(arg0 *route53.ListReusableDelegationSetsInput) (*request.Request, *route53.ListReusableDelegationSetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListReusableDelegationSetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListReusableDelegationSetsOutput) + return ret0, ret1 +} + +// ListReusableDelegationSetsRequest indicates an expected call of ListReusableDelegationSetsRequest. +func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSetsRequest), arg0) +} + +// ListReusableDelegationSetsWithContext mocks base method. +func (m *MockRoute53API) ListReusableDelegationSetsWithContext(arg0 aws.Context, arg1 *route53.ListReusableDelegationSetsInput, arg2 ...request.Option) (*route53.ListReusableDelegationSetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListReusableDelegationSetsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListReusableDelegationSetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListReusableDelegationSetsWithContext indicates an expected call of ListReusableDelegationSetsWithContext. +func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSetsWithContext), varargs...) +} + +// ListTagsForResource mocks base method. +func (m *MockRoute53API) ListTagsForResource(arg0 *route53.ListTagsForResourceInput) (*route53.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResource", arg0) + ret0, _ := ret[0].(*route53.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResource indicates an expected call of ListTagsForResource. +func (mr *MockRoute53APIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResource), arg0) +} + +// ListTagsForResourceRequest mocks base method. +func (m *MockRoute53API) ListTagsForResourceRequest(arg0 *route53.ListTagsForResourceInput) (*request.Request, *route53.ListTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListTagsForResourceOutput) + return ret0, ret1 +} + +// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest. +func (mr *MockRoute53APIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourceRequest), arg0) +} + +// ListTagsForResourceWithContext mocks base method. +func (m *MockRoute53API) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *route53.ListTagsForResourceInput, arg2 ...request.Option) (*route53.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].(*route53.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext. +func (mr *MockRoute53APIMockRecorder) 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((*MockRoute53API)(nil).ListTagsForResourceWithContext), varargs...) +} + +// ListTagsForResources mocks base method. +func (m *MockRoute53API) ListTagsForResources(arg0 *route53.ListTagsForResourcesInput) (*route53.ListTagsForResourcesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResources", arg0) + ret0, _ := ret[0].(*route53.ListTagsForResourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResources indicates an expected call of ListTagsForResources. +func (mr *MockRoute53APIMockRecorder) ListTagsForResources(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResources", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResources), arg0) +} + +// ListTagsForResourcesRequest mocks base method. +func (m *MockRoute53API) ListTagsForResourcesRequest(arg0 *route53.ListTagsForResourcesInput) (*request.Request, *route53.ListTagsForResourcesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourcesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListTagsForResourcesOutput) + return ret0, ret1 +} + +// ListTagsForResourcesRequest indicates an expected call of ListTagsForResourcesRequest. +func (mr *MockRoute53APIMockRecorder) ListTagsForResourcesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourcesRequest), arg0) +} + +// ListTagsForResourcesWithContext mocks base method. +func (m *MockRoute53API) ListTagsForResourcesWithContext(arg0 aws.Context, arg1 *route53.ListTagsForResourcesInput, arg2 ...request.Option) (*route53.ListTagsForResourcesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsForResourcesWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListTagsForResourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourcesWithContext indicates an expected call of ListTagsForResourcesWithContext. +func (mr *MockRoute53APIMockRecorder) ListTagsForResourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourcesWithContext), varargs...) +} + +// ListTrafficPolicies mocks base method. +func (m *MockRoute53API) ListTrafficPolicies(arg0 *route53.ListTrafficPoliciesInput) (*route53.ListTrafficPoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicies", arg0) + ret0, _ := ret[0].(*route53.ListTrafficPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicies indicates an expected call of ListTrafficPolicies. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicies", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicies), arg0) +} + +// ListTrafficPoliciesRequest mocks base method. +func (m *MockRoute53API) ListTrafficPoliciesRequest(arg0 *route53.ListTrafficPoliciesInput) (*request.Request, *route53.ListTrafficPoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListTrafficPoliciesOutput) + return ret0, ret1 +} + +// ListTrafficPoliciesRequest indicates an expected call of ListTrafficPoliciesRequest. +func (mr *MockRoute53APIMockRecorder) ListTrafficPoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPoliciesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPoliciesRequest), arg0) +} + +// ListTrafficPoliciesWithContext mocks base method. +func (m *MockRoute53API) ListTrafficPoliciesWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPoliciesInput, arg2 ...request.Option) (*route53.ListTrafficPoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTrafficPoliciesWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListTrafficPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPoliciesWithContext indicates an expected call of ListTrafficPoliciesWithContext. +func (mr *MockRoute53APIMockRecorder) ListTrafficPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPoliciesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPoliciesWithContext), varargs...) +} + +// ListTrafficPolicyInstances mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstances(arg0 *route53.ListTrafficPolicyInstancesInput) (*route53.ListTrafficPolicyInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicyInstances", arg0) + ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicyInstances indicates an expected call of ListTrafficPolicyInstances. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstances", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstances), arg0) +} + +// ListTrafficPolicyInstancesByHostedZone mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZone(arg0 *route53.ListTrafficPolicyInstancesByHostedZoneInput) (*route53.ListTrafficPolicyInstancesByHostedZoneOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZone", arg0) + ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicyInstancesByHostedZone indicates an expected call of ListTrafficPolicyInstancesByHostedZone. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZone(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZone", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZone), arg0) +} + +// ListTrafficPolicyInstancesByHostedZoneRequest mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZoneRequest(arg0 *route53.ListTrafficPolicyInstancesByHostedZoneInput) (*request.Request, *route53.ListTrafficPolicyInstancesByHostedZoneOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZoneRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput) + return ret0, ret1 +} + +// ListTrafficPolicyInstancesByHostedZoneRequest indicates an expected call of ListTrafficPolicyInstancesByHostedZoneRequest. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZoneRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZoneRequest), arg0) +} + +// ListTrafficPolicyInstancesByHostedZoneWithContext mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZoneWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesByHostedZoneInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesByHostedZoneOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZoneWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicyInstancesByHostedZoneWithContext indicates an expected call of ListTrafficPolicyInstancesByHostedZoneWithContext. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZoneWithContext), varargs...) +} + +// ListTrafficPolicyInstancesByPolicy mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicy(arg0 *route53.ListTrafficPolicyInstancesByPolicyInput) (*route53.ListTrafficPolicyInstancesByPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicy", arg0) + ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicyInstancesByPolicy indicates an expected call of ListTrafficPolicyInstancesByPolicy. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicy", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicy), arg0) +} + +// ListTrafficPolicyInstancesByPolicyRequest mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicyRequest(arg0 *route53.ListTrafficPolicyInstancesByPolicyInput) (*request.Request, *route53.ListTrafficPolicyInstancesByPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesByPolicyOutput) + return ret0, ret1 +} + +// ListTrafficPolicyInstancesByPolicyRequest indicates an expected call of ListTrafficPolicyInstancesByPolicyRequest. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicyRequest), arg0) +} + +// ListTrafficPolicyInstancesByPolicyWithContext mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicyWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesByPolicyInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesByPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicyInstancesByPolicyWithContext indicates an expected call of ListTrafficPolicyInstancesByPolicyWithContext. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicyWithContext), varargs...) +} + +// ListTrafficPolicyInstancesRequest mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstancesRequest(arg0 *route53.ListTrafficPolicyInstancesInput) (*request.Request, *route53.ListTrafficPolicyInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesOutput) + return ret0, ret1 +} + +// ListTrafficPolicyInstancesRequest indicates an expected call of ListTrafficPolicyInstancesRequest. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesRequest), arg0) +} + +// ListTrafficPolicyInstancesWithContext mocks base method. +func (m *MockRoute53API) ListTrafficPolicyInstancesWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicyInstancesWithContext indicates an expected call of ListTrafficPolicyInstancesWithContext. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesWithContext), varargs...) +} + +// ListTrafficPolicyVersions mocks base method. +func (m *MockRoute53API) ListTrafficPolicyVersions(arg0 *route53.ListTrafficPolicyVersionsInput) (*route53.ListTrafficPolicyVersionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicyVersions", arg0) + ret0, _ := ret[0].(*route53.ListTrafficPolicyVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicyVersions indicates an expected call of ListTrafficPolicyVersions. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersions", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersions), arg0) +} + +// ListTrafficPolicyVersionsRequest mocks base method. +func (m *MockRoute53API) ListTrafficPolicyVersionsRequest(arg0 *route53.ListTrafficPolicyVersionsInput) (*request.Request, *route53.ListTrafficPolicyVersionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrafficPolicyVersionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListTrafficPolicyVersionsOutput) + return ret0, ret1 +} + +// ListTrafficPolicyVersionsRequest indicates an expected call of ListTrafficPolicyVersionsRequest. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersionsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersionsRequest), arg0) +} + +// ListTrafficPolicyVersionsWithContext mocks base method. +func (m *MockRoute53API) ListTrafficPolicyVersionsWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyVersionsInput, arg2 ...request.Option) (*route53.ListTrafficPolicyVersionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTrafficPolicyVersionsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListTrafficPolicyVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrafficPolicyVersionsWithContext indicates an expected call of ListTrafficPolicyVersionsWithContext. +func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersionsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersionsWithContext), varargs...) +} + +// ListVPCAssociationAuthorizations mocks base method. +func (m *MockRoute53API) ListVPCAssociationAuthorizations(arg0 *route53.ListVPCAssociationAuthorizationsInput) (*route53.ListVPCAssociationAuthorizationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizations", arg0) + ret0, _ := ret[0].(*route53.ListVPCAssociationAuthorizationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListVPCAssociationAuthorizations indicates an expected call of ListVPCAssociationAuthorizations. +func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizations", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizations), arg0) +} + +// ListVPCAssociationAuthorizationsRequest mocks base method. +func (m *MockRoute53API) ListVPCAssociationAuthorizationsRequest(arg0 *route53.ListVPCAssociationAuthorizationsInput) (*request.Request, *route53.ListVPCAssociationAuthorizationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.ListVPCAssociationAuthorizationsOutput) + return ret0, ret1 +} + +// ListVPCAssociationAuthorizationsRequest indicates an expected call of ListVPCAssociationAuthorizationsRequest. +func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizationsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizationsRequest), arg0) +} + +// ListVPCAssociationAuthorizationsWithContext mocks base method. +func (m *MockRoute53API) ListVPCAssociationAuthorizationsWithContext(arg0 aws.Context, arg1 *route53.ListVPCAssociationAuthorizationsInput, arg2 ...request.Option) (*route53.ListVPCAssociationAuthorizationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizationsWithContext", varargs...) + ret0, _ := ret[0].(*route53.ListVPCAssociationAuthorizationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListVPCAssociationAuthorizationsWithContext indicates an expected call of ListVPCAssociationAuthorizationsWithContext. +func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizationsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizationsWithContext), varargs...) +} + +// TestDNSAnswer mocks base method. +func (m *MockRoute53API) TestDNSAnswer(arg0 *route53.TestDNSAnswerInput) (*route53.TestDNSAnswerOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TestDNSAnswer", arg0) + ret0, _ := ret[0].(*route53.TestDNSAnswerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TestDNSAnswer indicates an expected call of TestDNSAnswer. +func (mr *MockRoute53APIMockRecorder) TestDNSAnswer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswer", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswer), arg0) +} + +// TestDNSAnswerRequest mocks base method. +func (m *MockRoute53API) TestDNSAnswerRequest(arg0 *route53.TestDNSAnswerInput) (*request.Request, *route53.TestDNSAnswerOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TestDNSAnswerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.TestDNSAnswerOutput) + return ret0, ret1 +} + +// TestDNSAnswerRequest indicates an expected call of TestDNSAnswerRequest. +func (mr *MockRoute53APIMockRecorder) TestDNSAnswerRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswerRequest", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswerRequest), arg0) +} + +// TestDNSAnswerWithContext mocks base method. +func (m *MockRoute53API) TestDNSAnswerWithContext(arg0 aws.Context, arg1 *route53.TestDNSAnswerInput, arg2 ...request.Option) (*route53.TestDNSAnswerOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TestDNSAnswerWithContext", varargs...) + ret0, _ := ret[0].(*route53.TestDNSAnswerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TestDNSAnswerWithContext indicates an expected call of TestDNSAnswerWithContext. +func (mr *MockRoute53APIMockRecorder) TestDNSAnswerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswerWithContext", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswerWithContext), varargs...) +} + +// UpdateHealthCheck mocks base method. +func (m *MockRoute53API) UpdateHealthCheck(arg0 *route53.UpdateHealthCheckInput) (*route53.UpdateHealthCheckOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateHealthCheck", arg0) + ret0, _ := ret[0].(*route53.UpdateHealthCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateHealthCheck indicates an expected call of UpdateHealthCheck. +func (mr *MockRoute53APIMockRecorder) UpdateHealthCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheck), arg0) +} + +// UpdateHealthCheckRequest mocks base method. +func (m *MockRoute53API) UpdateHealthCheckRequest(arg0 *route53.UpdateHealthCheckInput) (*request.Request, *route53.UpdateHealthCheckOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateHealthCheckRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.UpdateHealthCheckOutput) + return ret0, ret1 +} + +// UpdateHealthCheckRequest indicates an expected call of UpdateHealthCheckRequest. +func (mr *MockRoute53APIMockRecorder) UpdateHealthCheckRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheckRequest), arg0) +} + +// UpdateHealthCheckWithContext mocks base method. +func (m *MockRoute53API) UpdateHealthCheckWithContext(arg0 aws.Context, arg1 *route53.UpdateHealthCheckInput, arg2 ...request.Option) (*route53.UpdateHealthCheckOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateHealthCheckWithContext", varargs...) + ret0, _ := ret[0].(*route53.UpdateHealthCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateHealthCheckWithContext indicates an expected call of UpdateHealthCheckWithContext. +func (mr *MockRoute53APIMockRecorder) UpdateHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheckWithContext), varargs...) +} + +// UpdateHostedZoneComment mocks base method. +func (m *MockRoute53API) UpdateHostedZoneComment(arg0 *route53.UpdateHostedZoneCommentInput) (*route53.UpdateHostedZoneCommentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateHostedZoneComment", arg0) + ret0, _ := ret[0].(*route53.UpdateHostedZoneCommentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateHostedZoneComment indicates an expected call of UpdateHostedZoneComment. +func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneComment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneComment", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneComment), arg0) +} + +// UpdateHostedZoneCommentRequest mocks base method. +func (m *MockRoute53API) UpdateHostedZoneCommentRequest(arg0 *route53.UpdateHostedZoneCommentInput) (*request.Request, *route53.UpdateHostedZoneCommentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateHostedZoneCommentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.UpdateHostedZoneCommentOutput) + return ret0, ret1 +} + +// UpdateHostedZoneCommentRequest indicates an expected call of UpdateHostedZoneCommentRequest. +func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneCommentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneCommentRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneCommentRequest), arg0) +} + +// UpdateHostedZoneCommentWithContext mocks base method. +func (m *MockRoute53API) UpdateHostedZoneCommentWithContext(arg0 aws.Context, arg1 *route53.UpdateHostedZoneCommentInput, arg2 ...request.Option) (*route53.UpdateHostedZoneCommentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateHostedZoneCommentWithContext", varargs...) + ret0, _ := ret[0].(*route53.UpdateHostedZoneCommentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateHostedZoneCommentWithContext indicates an expected call of UpdateHostedZoneCommentWithContext. +func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneCommentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneCommentWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneCommentWithContext), varargs...) +} + +// UpdateTrafficPolicyComment mocks base method. +func (m *MockRoute53API) UpdateTrafficPolicyComment(arg0 *route53.UpdateTrafficPolicyCommentInput) (*route53.UpdateTrafficPolicyCommentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTrafficPolicyComment", arg0) + ret0, _ := ret[0].(*route53.UpdateTrafficPolicyCommentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateTrafficPolicyComment indicates an expected call of UpdateTrafficPolicyComment. +func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyComment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyComment", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyComment), arg0) +} + +// UpdateTrafficPolicyCommentRequest mocks base method. +func (m *MockRoute53API) UpdateTrafficPolicyCommentRequest(arg0 *route53.UpdateTrafficPolicyCommentInput) (*request.Request, *route53.UpdateTrafficPolicyCommentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTrafficPolicyCommentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.UpdateTrafficPolicyCommentOutput) + return ret0, ret1 +} + +// UpdateTrafficPolicyCommentRequest indicates an expected call of UpdateTrafficPolicyCommentRequest. +func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyCommentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyCommentRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyCommentRequest), arg0) +} + +// UpdateTrafficPolicyCommentWithContext mocks base method. +func (m *MockRoute53API) UpdateTrafficPolicyCommentWithContext(arg0 aws.Context, arg1 *route53.UpdateTrafficPolicyCommentInput, arg2 ...request.Option) (*route53.UpdateTrafficPolicyCommentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateTrafficPolicyCommentWithContext", varargs...) + ret0, _ := ret[0].(*route53.UpdateTrafficPolicyCommentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateTrafficPolicyCommentWithContext indicates an expected call of UpdateTrafficPolicyCommentWithContext. +func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyCommentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyCommentWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyCommentWithContext), varargs...) +} + +// UpdateTrafficPolicyInstance mocks base method. +func (m *MockRoute53API) UpdateTrafficPolicyInstance(arg0 *route53.UpdateTrafficPolicyInstanceInput) (*route53.UpdateTrafficPolicyInstanceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstance", arg0) + ret0, _ := ret[0].(*route53.UpdateTrafficPolicyInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateTrafficPolicyInstance indicates an expected call of UpdateTrafficPolicyInstance. +func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstance), arg0) +} + +// UpdateTrafficPolicyInstanceRequest mocks base method. +func (m *MockRoute53API) UpdateTrafficPolicyInstanceRequest(arg0 *route53.UpdateTrafficPolicyInstanceInput) (*request.Request, *route53.UpdateTrafficPolicyInstanceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstanceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53.UpdateTrafficPolicyInstanceOutput) + return ret0, ret1 +} + +// UpdateTrafficPolicyInstanceRequest indicates an expected call of UpdateTrafficPolicyInstanceRequest. +func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstanceRequest), arg0) +} + +// UpdateTrafficPolicyInstanceWithContext mocks base method. +func (m *MockRoute53API) UpdateTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.UpdateTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.UpdateTrafficPolicyInstanceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstanceWithContext", varargs...) + ret0, _ := ret[0].(*route53.UpdateTrafficPolicyInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateTrafficPolicyInstanceWithContext indicates an expected call of UpdateTrafficPolicyInstanceWithContext. +func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstanceWithContext), varargs...) +} + +// WaitUntilResourceRecordSetsChanged mocks base method. +func (m *MockRoute53API) WaitUntilResourceRecordSetsChanged(arg0 *route53.GetChangeInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilResourceRecordSetsChanged", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilResourceRecordSetsChanged indicates an expected call of WaitUntilResourceRecordSetsChanged. +func (mr *MockRoute53APIMockRecorder) WaitUntilResourceRecordSetsChanged(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilResourceRecordSetsChanged", reflect.TypeOf((*MockRoute53API)(nil).WaitUntilResourceRecordSetsChanged), arg0) +} + +// WaitUntilResourceRecordSetsChangedWithContext mocks base method. +func (m *MockRoute53API) WaitUntilResourceRecordSetsChangedWithContext(arg0 aws.Context, arg1 *route53.GetChangeInput, 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, "WaitUntilResourceRecordSetsChangedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilResourceRecordSetsChangedWithContext indicates an expected call of WaitUntilResourceRecordSetsChangedWithContext. +func (mr *MockRoute53APIMockRecorder) WaitUntilResourceRecordSetsChangedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilResourceRecordSetsChangedWithContext", reflect.TypeOf((*MockRoute53API)(nil).WaitUntilResourceRecordSetsChangedWithContext), varargs...) +} diff --git a/resources/route53_mock_test.go b/resources/route53_mock_test.go new file mode 100644 index 00000000..ae38e54d --- /dev/null +++ b/resources/route53_mock_test.go @@ -0,0 +1,4 @@ +//go:generate ../mocks/generate_mocks.sh route53 route53iface +package resources + +// Note: empty on purpose, this file exist purely to generate mocks for the Route53 service From fd4b87db3ce4f03cf645d79995f2bad453a9326a Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 11 Sep 2024 12:04:16 -0600 Subject: [PATCH 3/5] test(route53): adding mocks for testing route53resolver --- mocks/mock_route53resolveriface/mock.go | 3965 +++++++++++++++++++++++ resources/route53_mock_test.go | 1 + 2 files changed, 3966 insertions(+) create mode 100644 mocks/mock_route53resolveriface/mock.go diff --git a/mocks/mock_route53resolveriface/mock.go b/mocks/mock_route53resolveriface/mock.go new file mode 100644 index 00000000..7eeabf8f --- /dev/null +++ b/mocks/mock_route53resolveriface/mock.go @@ -0,0 +1,3965 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/ekristen/go/pkg/mod/github.com/aws/aws-sdk-go@v1.54.20/service/route53resolver/route53resolveriface/interface.go + +// Package mock_route53resolveriface is a generated GoMock package. +package mock_route53resolveriface + +import ( + reflect "reflect" + + aws "github.com/aws/aws-sdk-go/aws" + request "github.com/aws/aws-sdk-go/aws/request" + route53resolver "github.com/aws/aws-sdk-go/service/route53resolver" + gomock "github.com/golang/mock/gomock" +) + +// MockRoute53ResolverAPI is a mock of Route53ResolverAPI interface. +type MockRoute53ResolverAPI struct { + ctrl *gomock.Controller + recorder *MockRoute53ResolverAPIMockRecorder +} + +// MockRoute53ResolverAPIMockRecorder is the mock recorder for MockRoute53ResolverAPI. +type MockRoute53ResolverAPIMockRecorder struct { + mock *MockRoute53ResolverAPI +} + +// NewMockRoute53ResolverAPI creates a new mock instance. +func NewMockRoute53ResolverAPI(ctrl *gomock.Controller) *MockRoute53ResolverAPI { + mock := &MockRoute53ResolverAPI{ctrl: ctrl} + mock.recorder = &MockRoute53ResolverAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRoute53ResolverAPI) EXPECT() *MockRoute53ResolverAPIMockRecorder { + return m.recorder +} + +// AssociateFirewallRuleGroup mocks base method. +func (m *MockRoute53ResolverAPI) AssociateFirewallRuleGroup(arg0 *route53resolver.AssociateFirewallRuleGroupInput) (*route53resolver.AssociateFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateFirewallRuleGroup", arg0) + ret0, _ := ret[0].(*route53resolver.AssociateFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateFirewallRuleGroup indicates an expected call of AssociateFirewallRuleGroup. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateFirewallRuleGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateFirewallRuleGroup", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateFirewallRuleGroup), arg0) +} + +// AssociateFirewallRuleGroupRequest mocks base method. +func (m *MockRoute53ResolverAPI) AssociateFirewallRuleGroupRequest(arg0 *route53resolver.AssociateFirewallRuleGroupInput) (*request.Request, *route53resolver.AssociateFirewallRuleGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateFirewallRuleGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.AssociateFirewallRuleGroupOutput) + return ret0, ret1 +} + +// AssociateFirewallRuleGroupRequest indicates an expected call of AssociateFirewallRuleGroupRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateFirewallRuleGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateFirewallRuleGroupRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateFirewallRuleGroupRequest), arg0) +} + +// AssociateFirewallRuleGroupWithContext mocks base method. +func (m *MockRoute53ResolverAPI) AssociateFirewallRuleGroupWithContext(arg0 aws.Context, arg1 *route53resolver.AssociateFirewallRuleGroupInput, arg2 ...request.Option) (*route53resolver.AssociateFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateFirewallRuleGroupWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.AssociateFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateFirewallRuleGroupWithContext indicates an expected call of AssociateFirewallRuleGroupWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateFirewallRuleGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateFirewallRuleGroupWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateFirewallRuleGroupWithContext), varargs...) +} + +// AssociateResolverEndpointIpAddress mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverEndpointIpAddress(arg0 *route53resolver.AssociateResolverEndpointIpAddressInput) (*route53resolver.AssociateResolverEndpointIpAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateResolverEndpointIpAddress", arg0) + ret0, _ := ret[0].(*route53resolver.AssociateResolverEndpointIpAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateResolverEndpointIpAddress indicates an expected call of AssociateResolverEndpointIpAddress. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverEndpointIpAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverEndpointIpAddress", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverEndpointIpAddress), arg0) +} + +// AssociateResolverEndpointIpAddressRequest mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverEndpointIpAddressRequest(arg0 *route53resolver.AssociateResolverEndpointIpAddressInput) (*request.Request, *route53resolver.AssociateResolverEndpointIpAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateResolverEndpointIpAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.AssociateResolverEndpointIpAddressOutput) + return ret0, ret1 +} + +// AssociateResolverEndpointIpAddressRequest indicates an expected call of AssociateResolverEndpointIpAddressRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverEndpointIpAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverEndpointIpAddressRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverEndpointIpAddressRequest), arg0) +} + +// AssociateResolverEndpointIpAddressWithContext mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverEndpointIpAddressWithContext(arg0 aws.Context, arg1 *route53resolver.AssociateResolverEndpointIpAddressInput, arg2 ...request.Option) (*route53resolver.AssociateResolverEndpointIpAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateResolverEndpointIpAddressWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.AssociateResolverEndpointIpAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateResolverEndpointIpAddressWithContext indicates an expected call of AssociateResolverEndpointIpAddressWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverEndpointIpAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverEndpointIpAddressWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverEndpointIpAddressWithContext), varargs...) +} + +// AssociateResolverQueryLogConfig mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverQueryLogConfig(arg0 *route53resolver.AssociateResolverQueryLogConfigInput) (*route53resolver.AssociateResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateResolverQueryLogConfig", arg0) + ret0, _ := ret[0].(*route53resolver.AssociateResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateResolverQueryLogConfig indicates an expected call of AssociateResolverQueryLogConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverQueryLogConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverQueryLogConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverQueryLogConfig), arg0) +} + +// AssociateResolverQueryLogConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverQueryLogConfigRequest(arg0 *route53resolver.AssociateResolverQueryLogConfigInput) (*request.Request, *route53resolver.AssociateResolverQueryLogConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateResolverQueryLogConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.AssociateResolverQueryLogConfigOutput) + return ret0, ret1 +} + +// AssociateResolverQueryLogConfigRequest indicates an expected call of AssociateResolverQueryLogConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverQueryLogConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverQueryLogConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverQueryLogConfigRequest), arg0) +} + +// AssociateResolverQueryLogConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverQueryLogConfigWithContext(arg0 aws.Context, arg1 *route53resolver.AssociateResolverQueryLogConfigInput, arg2 ...request.Option) (*route53resolver.AssociateResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateResolverQueryLogConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.AssociateResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateResolverQueryLogConfigWithContext indicates an expected call of AssociateResolverQueryLogConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverQueryLogConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverQueryLogConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverQueryLogConfigWithContext), varargs...) +} + +// AssociateResolverRule mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverRule(arg0 *route53resolver.AssociateResolverRuleInput) (*route53resolver.AssociateResolverRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateResolverRule", arg0) + ret0, _ := ret[0].(*route53resolver.AssociateResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateResolverRule indicates an expected call of AssociateResolverRule. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverRule), arg0) +} + +// AssociateResolverRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverRuleRequest(arg0 *route53resolver.AssociateResolverRuleInput) (*request.Request, *route53resolver.AssociateResolverRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateResolverRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.AssociateResolverRuleOutput) + return ret0, ret1 +} + +// AssociateResolverRuleRequest indicates an expected call of AssociateResolverRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverRuleRequest), arg0) +} + +// AssociateResolverRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) AssociateResolverRuleWithContext(arg0 aws.Context, arg1 *route53resolver.AssociateResolverRuleInput, arg2 ...request.Option) (*route53resolver.AssociateResolverRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateResolverRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.AssociateResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateResolverRuleWithContext indicates an expected call of AssociateResolverRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) AssociateResolverRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateResolverRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).AssociateResolverRuleWithContext), varargs...) +} + +// CreateFirewallDomainList mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallDomainList(arg0 *route53resolver.CreateFirewallDomainListInput) (*route53resolver.CreateFirewallDomainListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFirewallDomainList", arg0) + ret0, _ := ret[0].(*route53resolver.CreateFirewallDomainListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFirewallDomainList indicates an expected call of CreateFirewallDomainList. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallDomainList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallDomainList", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallDomainList), arg0) +} + +// CreateFirewallDomainListRequest mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallDomainListRequest(arg0 *route53resolver.CreateFirewallDomainListInput) (*request.Request, *route53resolver.CreateFirewallDomainListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFirewallDomainListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.CreateFirewallDomainListOutput) + return ret0, ret1 +} + +// CreateFirewallDomainListRequest indicates an expected call of CreateFirewallDomainListRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallDomainListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallDomainListRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallDomainListRequest), arg0) +} + +// CreateFirewallDomainListWithContext mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallDomainListWithContext(arg0 aws.Context, arg1 *route53resolver.CreateFirewallDomainListInput, arg2 ...request.Option) (*route53resolver.CreateFirewallDomainListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateFirewallDomainListWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.CreateFirewallDomainListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFirewallDomainListWithContext indicates an expected call of CreateFirewallDomainListWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallDomainListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallDomainListWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallDomainListWithContext), varargs...) +} + +// CreateFirewallRule mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallRule(arg0 *route53resolver.CreateFirewallRuleInput) (*route53resolver.CreateFirewallRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFirewallRule", arg0) + ret0, _ := ret[0].(*route53resolver.CreateFirewallRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFirewallRule indicates an expected call of CreateFirewallRule. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallRule), arg0) +} + +// CreateFirewallRuleGroup mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallRuleGroup(arg0 *route53resolver.CreateFirewallRuleGroupInput) (*route53resolver.CreateFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFirewallRuleGroup", arg0) + ret0, _ := ret[0].(*route53resolver.CreateFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFirewallRuleGroup indicates an expected call of CreateFirewallRuleGroup. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallRuleGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallRuleGroup", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallRuleGroup), arg0) +} + +// CreateFirewallRuleGroupRequest mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallRuleGroupRequest(arg0 *route53resolver.CreateFirewallRuleGroupInput) (*request.Request, *route53resolver.CreateFirewallRuleGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFirewallRuleGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.CreateFirewallRuleGroupOutput) + return ret0, ret1 +} + +// CreateFirewallRuleGroupRequest indicates an expected call of CreateFirewallRuleGroupRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallRuleGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallRuleGroupRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallRuleGroupRequest), arg0) +} + +// CreateFirewallRuleGroupWithContext mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallRuleGroupWithContext(arg0 aws.Context, arg1 *route53resolver.CreateFirewallRuleGroupInput, arg2 ...request.Option) (*route53resolver.CreateFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateFirewallRuleGroupWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.CreateFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFirewallRuleGroupWithContext indicates an expected call of CreateFirewallRuleGroupWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallRuleGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallRuleGroupWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallRuleGroupWithContext), varargs...) +} + +// CreateFirewallRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallRuleRequest(arg0 *route53resolver.CreateFirewallRuleInput) (*request.Request, *route53resolver.CreateFirewallRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFirewallRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.CreateFirewallRuleOutput) + return ret0, ret1 +} + +// CreateFirewallRuleRequest indicates an expected call of CreateFirewallRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallRuleRequest), arg0) +} + +// CreateFirewallRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) CreateFirewallRuleWithContext(arg0 aws.Context, arg1 *route53resolver.CreateFirewallRuleInput, arg2 ...request.Option) (*route53resolver.CreateFirewallRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateFirewallRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.CreateFirewallRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFirewallRuleWithContext indicates an expected call of CreateFirewallRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateFirewallRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFirewallRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateFirewallRuleWithContext), varargs...) +} + +// CreateOutpostResolver mocks base method. +func (m *MockRoute53ResolverAPI) CreateOutpostResolver(arg0 *route53resolver.CreateOutpostResolverInput) (*route53resolver.CreateOutpostResolverOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOutpostResolver", arg0) + ret0, _ := ret[0].(*route53resolver.CreateOutpostResolverOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOutpostResolver indicates an expected call of CreateOutpostResolver. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateOutpostResolver(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOutpostResolver", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateOutpostResolver), arg0) +} + +// CreateOutpostResolverRequest mocks base method. +func (m *MockRoute53ResolverAPI) CreateOutpostResolverRequest(arg0 *route53resolver.CreateOutpostResolverInput) (*request.Request, *route53resolver.CreateOutpostResolverOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOutpostResolverRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.CreateOutpostResolverOutput) + return ret0, ret1 +} + +// CreateOutpostResolverRequest indicates an expected call of CreateOutpostResolverRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateOutpostResolverRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOutpostResolverRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateOutpostResolverRequest), arg0) +} + +// CreateOutpostResolverWithContext mocks base method. +func (m *MockRoute53ResolverAPI) CreateOutpostResolverWithContext(arg0 aws.Context, arg1 *route53resolver.CreateOutpostResolverInput, arg2 ...request.Option) (*route53resolver.CreateOutpostResolverOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateOutpostResolverWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.CreateOutpostResolverOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOutpostResolverWithContext indicates an expected call of CreateOutpostResolverWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateOutpostResolverWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOutpostResolverWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateOutpostResolverWithContext), varargs...) +} + +// CreateResolverEndpoint mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverEndpoint(arg0 *route53resolver.CreateResolverEndpointInput) (*route53resolver.CreateResolverEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateResolverEndpoint", arg0) + ret0, _ := ret[0].(*route53resolver.CreateResolverEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateResolverEndpoint indicates an expected call of CreateResolverEndpoint. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverEndpoint", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverEndpoint), arg0) +} + +// CreateResolverEndpointRequest mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverEndpointRequest(arg0 *route53resolver.CreateResolverEndpointInput) (*request.Request, *route53resolver.CreateResolverEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateResolverEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.CreateResolverEndpointOutput) + return ret0, ret1 +} + +// CreateResolverEndpointRequest indicates an expected call of CreateResolverEndpointRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverEndpointRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverEndpointRequest), arg0) +} + +// CreateResolverEndpointWithContext mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverEndpointWithContext(arg0 aws.Context, arg1 *route53resolver.CreateResolverEndpointInput, arg2 ...request.Option) (*route53resolver.CreateResolverEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateResolverEndpointWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.CreateResolverEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateResolverEndpointWithContext indicates an expected call of CreateResolverEndpointWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverEndpointWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverEndpointWithContext), varargs...) +} + +// CreateResolverQueryLogConfig mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverQueryLogConfig(arg0 *route53resolver.CreateResolverQueryLogConfigInput) (*route53resolver.CreateResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateResolverQueryLogConfig", arg0) + ret0, _ := ret[0].(*route53resolver.CreateResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateResolverQueryLogConfig indicates an expected call of CreateResolverQueryLogConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverQueryLogConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverQueryLogConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverQueryLogConfig), arg0) +} + +// CreateResolverQueryLogConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverQueryLogConfigRequest(arg0 *route53resolver.CreateResolverQueryLogConfigInput) (*request.Request, *route53resolver.CreateResolverQueryLogConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateResolverQueryLogConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.CreateResolverQueryLogConfigOutput) + return ret0, ret1 +} + +// CreateResolverQueryLogConfigRequest indicates an expected call of CreateResolverQueryLogConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverQueryLogConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverQueryLogConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverQueryLogConfigRequest), arg0) +} + +// CreateResolverQueryLogConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverQueryLogConfigWithContext(arg0 aws.Context, arg1 *route53resolver.CreateResolverQueryLogConfigInput, arg2 ...request.Option) (*route53resolver.CreateResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateResolverQueryLogConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.CreateResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateResolverQueryLogConfigWithContext indicates an expected call of CreateResolverQueryLogConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverQueryLogConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverQueryLogConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverQueryLogConfigWithContext), varargs...) +} + +// CreateResolverRule mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverRule(arg0 *route53resolver.CreateResolverRuleInput) (*route53resolver.CreateResolverRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateResolverRule", arg0) + ret0, _ := ret[0].(*route53resolver.CreateResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateResolverRule indicates an expected call of CreateResolverRule. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverRule), arg0) +} + +// CreateResolverRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverRuleRequest(arg0 *route53resolver.CreateResolverRuleInput) (*request.Request, *route53resolver.CreateResolverRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateResolverRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.CreateResolverRuleOutput) + return ret0, ret1 +} + +// CreateResolverRuleRequest indicates an expected call of CreateResolverRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverRuleRequest), arg0) +} + +// CreateResolverRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) CreateResolverRuleWithContext(arg0 aws.Context, arg1 *route53resolver.CreateResolverRuleInput, arg2 ...request.Option) (*route53resolver.CreateResolverRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateResolverRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.CreateResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateResolverRuleWithContext indicates an expected call of CreateResolverRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) CreateResolverRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResolverRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).CreateResolverRuleWithContext), varargs...) +} + +// DeleteFirewallDomainList mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallDomainList(arg0 *route53resolver.DeleteFirewallDomainListInput) (*route53resolver.DeleteFirewallDomainListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFirewallDomainList", arg0) + ret0, _ := ret[0].(*route53resolver.DeleteFirewallDomainListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFirewallDomainList indicates an expected call of DeleteFirewallDomainList. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallDomainList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallDomainList", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallDomainList), arg0) +} + +// DeleteFirewallDomainListRequest mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallDomainListRequest(arg0 *route53resolver.DeleteFirewallDomainListInput) (*request.Request, *route53resolver.DeleteFirewallDomainListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFirewallDomainListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DeleteFirewallDomainListOutput) + return ret0, ret1 +} + +// DeleteFirewallDomainListRequest indicates an expected call of DeleteFirewallDomainListRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallDomainListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallDomainListRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallDomainListRequest), arg0) +} + +// DeleteFirewallDomainListWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallDomainListWithContext(arg0 aws.Context, arg1 *route53resolver.DeleteFirewallDomainListInput, arg2 ...request.Option) (*route53resolver.DeleteFirewallDomainListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteFirewallDomainListWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DeleteFirewallDomainListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFirewallDomainListWithContext indicates an expected call of DeleteFirewallDomainListWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallDomainListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallDomainListWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallDomainListWithContext), varargs...) +} + +// DeleteFirewallRule mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallRule(arg0 *route53resolver.DeleteFirewallRuleInput) (*route53resolver.DeleteFirewallRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFirewallRule", arg0) + ret0, _ := ret[0].(*route53resolver.DeleteFirewallRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFirewallRule indicates an expected call of DeleteFirewallRule. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallRule), arg0) +} + +// DeleteFirewallRuleGroup mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallRuleGroup(arg0 *route53resolver.DeleteFirewallRuleGroupInput) (*route53resolver.DeleteFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFirewallRuleGroup", arg0) + ret0, _ := ret[0].(*route53resolver.DeleteFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFirewallRuleGroup indicates an expected call of DeleteFirewallRuleGroup. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallRuleGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallRuleGroup", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallRuleGroup), arg0) +} + +// DeleteFirewallRuleGroupRequest mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallRuleGroupRequest(arg0 *route53resolver.DeleteFirewallRuleGroupInput) (*request.Request, *route53resolver.DeleteFirewallRuleGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFirewallRuleGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DeleteFirewallRuleGroupOutput) + return ret0, ret1 +} + +// DeleteFirewallRuleGroupRequest indicates an expected call of DeleteFirewallRuleGroupRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallRuleGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallRuleGroupRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallRuleGroupRequest), arg0) +} + +// DeleteFirewallRuleGroupWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallRuleGroupWithContext(arg0 aws.Context, arg1 *route53resolver.DeleteFirewallRuleGroupInput, arg2 ...request.Option) (*route53resolver.DeleteFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteFirewallRuleGroupWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DeleteFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFirewallRuleGroupWithContext indicates an expected call of DeleteFirewallRuleGroupWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallRuleGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallRuleGroupWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallRuleGroupWithContext), varargs...) +} + +// DeleteFirewallRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallRuleRequest(arg0 *route53resolver.DeleteFirewallRuleInput) (*request.Request, *route53resolver.DeleteFirewallRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFirewallRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DeleteFirewallRuleOutput) + return ret0, ret1 +} + +// DeleteFirewallRuleRequest indicates an expected call of DeleteFirewallRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallRuleRequest), arg0) +} + +// DeleteFirewallRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DeleteFirewallRuleWithContext(arg0 aws.Context, arg1 *route53resolver.DeleteFirewallRuleInput, arg2 ...request.Option) (*route53resolver.DeleteFirewallRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteFirewallRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DeleteFirewallRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFirewallRuleWithContext indicates an expected call of DeleteFirewallRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteFirewallRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFirewallRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteFirewallRuleWithContext), varargs...) +} + +// DeleteOutpostResolver mocks base method. +func (m *MockRoute53ResolverAPI) DeleteOutpostResolver(arg0 *route53resolver.DeleteOutpostResolverInput) (*route53resolver.DeleteOutpostResolverOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOutpostResolver", arg0) + ret0, _ := ret[0].(*route53resolver.DeleteOutpostResolverOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOutpostResolver indicates an expected call of DeleteOutpostResolver. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteOutpostResolver(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOutpostResolver", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteOutpostResolver), arg0) +} + +// DeleteOutpostResolverRequest mocks base method. +func (m *MockRoute53ResolverAPI) DeleteOutpostResolverRequest(arg0 *route53resolver.DeleteOutpostResolverInput) (*request.Request, *route53resolver.DeleteOutpostResolverOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOutpostResolverRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DeleteOutpostResolverOutput) + return ret0, ret1 +} + +// DeleteOutpostResolverRequest indicates an expected call of DeleteOutpostResolverRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteOutpostResolverRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOutpostResolverRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteOutpostResolverRequest), arg0) +} + +// DeleteOutpostResolverWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DeleteOutpostResolverWithContext(arg0 aws.Context, arg1 *route53resolver.DeleteOutpostResolverInput, arg2 ...request.Option) (*route53resolver.DeleteOutpostResolverOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteOutpostResolverWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DeleteOutpostResolverOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOutpostResolverWithContext indicates an expected call of DeleteOutpostResolverWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteOutpostResolverWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOutpostResolverWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteOutpostResolverWithContext), varargs...) +} + +// DeleteResolverEndpoint mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverEndpoint(arg0 *route53resolver.DeleteResolverEndpointInput) (*route53resolver.DeleteResolverEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteResolverEndpoint", arg0) + ret0, _ := ret[0].(*route53resolver.DeleteResolverEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteResolverEndpoint indicates an expected call of DeleteResolverEndpoint. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverEndpoint", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverEndpoint), arg0) +} + +// DeleteResolverEndpointRequest mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverEndpointRequest(arg0 *route53resolver.DeleteResolverEndpointInput) (*request.Request, *route53resolver.DeleteResolverEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteResolverEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DeleteResolverEndpointOutput) + return ret0, ret1 +} + +// DeleteResolverEndpointRequest indicates an expected call of DeleteResolverEndpointRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverEndpointRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverEndpointRequest), arg0) +} + +// DeleteResolverEndpointWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverEndpointWithContext(arg0 aws.Context, arg1 *route53resolver.DeleteResolverEndpointInput, arg2 ...request.Option) (*route53resolver.DeleteResolverEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteResolverEndpointWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DeleteResolverEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteResolverEndpointWithContext indicates an expected call of DeleteResolverEndpointWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverEndpointWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverEndpointWithContext), varargs...) +} + +// DeleteResolverQueryLogConfig mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverQueryLogConfig(arg0 *route53resolver.DeleteResolverQueryLogConfigInput) (*route53resolver.DeleteResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteResolverQueryLogConfig", arg0) + ret0, _ := ret[0].(*route53resolver.DeleteResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteResolverQueryLogConfig indicates an expected call of DeleteResolverQueryLogConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverQueryLogConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverQueryLogConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverQueryLogConfig), arg0) +} + +// DeleteResolverQueryLogConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverQueryLogConfigRequest(arg0 *route53resolver.DeleteResolverQueryLogConfigInput) (*request.Request, *route53resolver.DeleteResolverQueryLogConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteResolverQueryLogConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DeleteResolverQueryLogConfigOutput) + return ret0, ret1 +} + +// DeleteResolverQueryLogConfigRequest indicates an expected call of DeleteResolverQueryLogConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverQueryLogConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverQueryLogConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverQueryLogConfigRequest), arg0) +} + +// DeleteResolverQueryLogConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverQueryLogConfigWithContext(arg0 aws.Context, arg1 *route53resolver.DeleteResolverQueryLogConfigInput, arg2 ...request.Option) (*route53resolver.DeleteResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteResolverQueryLogConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DeleteResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteResolverQueryLogConfigWithContext indicates an expected call of DeleteResolverQueryLogConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverQueryLogConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverQueryLogConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverQueryLogConfigWithContext), varargs...) +} + +// DeleteResolverRule mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverRule(arg0 *route53resolver.DeleteResolverRuleInput) (*route53resolver.DeleteResolverRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteResolverRule", arg0) + ret0, _ := ret[0].(*route53resolver.DeleteResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteResolverRule indicates an expected call of DeleteResolverRule. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverRule), arg0) +} + +// DeleteResolverRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverRuleRequest(arg0 *route53resolver.DeleteResolverRuleInput) (*request.Request, *route53resolver.DeleteResolverRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteResolverRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DeleteResolverRuleOutput) + return ret0, ret1 +} + +// DeleteResolverRuleRequest indicates an expected call of DeleteResolverRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverRuleRequest), arg0) +} + +// DeleteResolverRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DeleteResolverRuleWithContext(arg0 aws.Context, arg1 *route53resolver.DeleteResolverRuleInput, arg2 ...request.Option) (*route53resolver.DeleteResolverRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteResolverRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DeleteResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteResolverRuleWithContext indicates an expected call of DeleteResolverRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DeleteResolverRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResolverRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DeleteResolverRuleWithContext), varargs...) +} + +// DisassociateFirewallRuleGroup mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateFirewallRuleGroup(arg0 *route53resolver.DisassociateFirewallRuleGroupInput) (*route53resolver.DisassociateFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateFirewallRuleGroup", arg0) + ret0, _ := ret[0].(*route53resolver.DisassociateFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateFirewallRuleGroup indicates an expected call of DisassociateFirewallRuleGroup. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateFirewallRuleGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateFirewallRuleGroup", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateFirewallRuleGroup), arg0) +} + +// DisassociateFirewallRuleGroupRequest mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateFirewallRuleGroupRequest(arg0 *route53resolver.DisassociateFirewallRuleGroupInput) (*request.Request, *route53resolver.DisassociateFirewallRuleGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateFirewallRuleGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DisassociateFirewallRuleGroupOutput) + return ret0, ret1 +} + +// DisassociateFirewallRuleGroupRequest indicates an expected call of DisassociateFirewallRuleGroupRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateFirewallRuleGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateFirewallRuleGroupRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateFirewallRuleGroupRequest), arg0) +} + +// DisassociateFirewallRuleGroupWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateFirewallRuleGroupWithContext(arg0 aws.Context, arg1 *route53resolver.DisassociateFirewallRuleGroupInput, arg2 ...request.Option) (*route53resolver.DisassociateFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateFirewallRuleGroupWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DisassociateFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateFirewallRuleGroupWithContext indicates an expected call of DisassociateFirewallRuleGroupWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateFirewallRuleGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateFirewallRuleGroupWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateFirewallRuleGroupWithContext), varargs...) +} + +// DisassociateResolverEndpointIpAddress mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverEndpointIpAddress(arg0 *route53resolver.DisassociateResolverEndpointIpAddressInput) (*route53resolver.DisassociateResolverEndpointIpAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateResolverEndpointIpAddress", arg0) + ret0, _ := ret[0].(*route53resolver.DisassociateResolverEndpointIpAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateResolverEndpointIpAddress indicates an expected call of DisassociateResolverEndpointIpAddress. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverEndpointIpAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverEndpointIpAddress", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverEndpointIpAddress), arg0) +} + +// DisassociateResolverEndpointIpAddressRequest mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverEndpointIpAddressRequest(arg0 *route53resolver.DisassociateResolverEndpointIpAddressInput) (*request.Request, *route53resolver.DisassociateResolverEndpointIpAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateResolverEndpointIpAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DisassociateResolverEndpointIpAddressOutput) + return ret0, ret1 +} + +// DisassociateResolverEndpointIpAddressRequest indicates an expected call of DisassociateResolverEndpointIpAddressRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverEndpointIpAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverEndpointIpAddressRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverEndpointIpAddressRequest), arg0) +} + +// DisassociateResolverEndpointIpAddressWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverEndpointIpAddressWithContext(arg0 aws.Context, arg1 *route53resolver.DisassociateResolverEndpointIpAddressInput, arg2 ...request.Option) (*route53resolver.DisassociateResolverEndpointIpAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateResolverEndpointIpAddressWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DisassociateResolverEndpointIpAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateResolverEndpointIpAddressWithContext indicates an expected call of DisassociateResolverEndpointIpAddressWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverEndpointIpAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverEndpointIpAddressWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverEndpointIpAddressWithContext), varargs...) +} + +// DisassociateResolverQueryLogConfig mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverQueryLogConfig(arg0 *route53resolver.DisassociateResolverQueryLogConfigInput) (*route53resolver.DisassociateResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateResolverQueryLogConfig", arg0) + ret0, _ := ret[0].(*route53resolver.DisassociateResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateResolverQueryLogConfig indicates an expected call of DisassociateResolverQueryLogConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverQueryLogConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverQueryLogConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverQueryLogConfig), arg0) +} + +// DisassociateResolverQueryLogConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverQueryLogConfigRequest(arg0 *route53resolver.DisassociateResolverQueryLogConfigInput) (*request.Request, *route53resolver.DisassociateResolverQueryLogConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateResolverQueryLogConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DisassociateResolverQueryLogConfigOutput) + return ret0, ret1 +} + +// DisassociateResolverQueryLogConfigRequest indicates an expected call of DisassociateResolverQueryLogConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverQueryLogConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverQueryLogConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverQueryLogConfigRequest), arg0) +} + +// DisassociateResolverQueryLogConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverQueryLogConfigWithContext(arg0 aws.Context, arg1 *route53resolver.DisassociateResolverQueryLogConfigInput, arg2 ...request.Option) (*route53resolver.DisassociateResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateResolverQueryLogConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DisassociateResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateResolverQueryLogConfigWithContext indicates an expected call of DisassociateResolverQueryLogConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverQueryLogConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverQueryLogConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverQueryLogConfigWithContext), varargs...) +} + +// DisassociateResolverRule mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverRule(arg0 *route53resolver.DisassociateResolverRuleInput) (*route53resolver.DisassociateResolverRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateResolverRule", arg0) + ret0, _ := ret[0].(*route53resolver.DisassociateResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateResolverRule indicates an expected call of DisassociateResolverRule. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverRule), arg0) +} + +// DisassociateResolverRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverRuleRequest(arg0 *route53resolver.DisassociateResolverRuleInput) (*request.Request, *route53resolver.DisassociateResolverRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateResolverRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.DisassociateResolverRuleOutput) + return ret0, ret1 +} + +// DisassociateResolverRuleRequest indicates an expected call of DisassociateResolverRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverRuleRequest), arg0) +} + +// DisassociateResolverRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) DisassociateResolverRuleWithContext(arg0 aws.Context, arg1 *route53resolver.DisassociateResolverRuleInput, arg2 ...request.Option) (*route53resolver.DisassociateResolverRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateResolverRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.DisassociateResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateResolverRuleWithContext indicates an expected call of DisassociateResolverRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) DisassociateResolverRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateResolverRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).DisassociateResolverRuleWithContext), varargs...) +} + +// GetFirewallConfig mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallConfig(arg0 *route53resolver.GetFirewallConfigInput) (*route53resolver.GetFirewallConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallConfig", arg0) + ret0, _ := ret[0].(*route53resolver.GetFirewallConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallConfig indicates an expected call of GetFirewallConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallConfig), arg0) +} + +// GetFirewallConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallConfigRequest(arg0 *route53resolver.GetFirewallConfigInput) (*request.Request, *route53resolver.GetFirewallConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetFirewallConfigOutput) + return ret0, ret1 +} + +// GetFirewallConfigRequest indicates an expected call of GetFirewallConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallConfigRequest), arg0) +} + +// GetFirewallConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallConfigWithContext(arg0 aws.Context, arg1 *route53resolver.GetFirewallConfigInput, arg2 ...request.Option) (*route53resolver.GetFirewallConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetFirewallConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetFirewallConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallConfigWithContext indicates an expected call of GetFirewallConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallConfigWithContext), varargs...) +} + +// GetFirewallDomainList mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallDomainList(arg0 *route53resolver.GetFirewallDomainListInput) (*route53resolver.GetFirewallDomainListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallDomainList", arg0) + ret0, _ := ret[0].(*route53resolver.GetFirewallDomainListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallDomainList indicates an expected call of GetFirewallDomainList. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallDomainList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallDomainList", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallDomainList), arg0) +} + +// GetFirewallDomainListRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallDomainListRequest(arg0 *route53resolver.GetFirewallDomainListInput) (*request.Request, *route53resolver.GetFirewallDomainListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallDomainListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetFirewallDomainListOutput) + return ret0, ret1 +} + +// GetFirewallDomainListRequest indicates an expected call of GetFirewallDomainListRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallDomainListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallDomainListRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallDomainListRequest), arg0) +} + +// GetFirewallDomainListWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallDomainListWithContext(arg0 aws.Context, arg1 *route53resolver.GetFirewallDomainListInput, arg2 ...request.Option) (*route53resolver.GetFirewallDomainListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetFirewallDomainListWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetFirewallDomainListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallDomainListWithContext indicates an expected call of GetFirewallDomainListWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallDomainListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallDomainListWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallDomainListWithContext), varargs...) +} + +// GetFirewallRuleGroup mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroup(arg0 *route53resolver.GetFirewallRuleGroupInput) (*route53resolver.GetFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallRuleGroup", arg0) + ret0, _ := ret[0].(*route53resolver.GetFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallRuleGroup indicates an expected call of GetFirewallRuleGroup. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroup", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroup), arg0) +} + +// GetFirewallRuleGroupAssociation mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroupAssociation(arg0 *route53resolver.GetFirewallRuleGroupAssociationInput) (*route53resolver.GetFirewallRuleGroupAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallRuleGroupAssociation", arg0) + ret0, _ := ret[0].(*route53resolver.GetFirewallRuleGroupAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallRuleGroupAssociation indicates an expected call of GetFirewallRuleGroupAssociation. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroupAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroupAssociation", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroupAssociation), arg0) +} + +// GetFirewallRuleGroupAssociationRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroupAssociationRequest(arg0 *route53resolver.GetFirewallRuleGroupAssociationInput) (*request.Request, *route53resolver.GetFirewallRuleGroupAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallRuleGroupAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetFirewallRuleGroupAssociationOutput) + return ret0, ret1 +} + +// GetFirewallRuleGroupAssociationRequest indicates an expected call of GetFirewallRuleGroupAssociationRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroupAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroupAssociationRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroupAssociationRequest), arg0) +} + +// GetFirewallRuleGroupAssociationWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroupAssociationWithContext(arg0 aws.Context, arg1 *route53resolver.GetFirewallRuleGroupAssociationInput, arg2 ...request.Option) (*route53resolver.GetFirewallRuleGroupAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetFirewallRuleGroupAssociationWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetFirewallRuleGroupAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallRuleGroupAssociationWithContext indicates an expected call of GetFirewallRuleGroupAssociationWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroupAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroupAssociationWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroupAssociationWithContext), varargs...) +} + +// GetFirewallRuleGroupPolicy mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroupPolicy(arg0 *route53resolver.GetFirewallRuleGroupPolicyInput) (*route53resolver.GetFirewallRuleGroupPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallRuleGroupPolicy", arg0) + ret0, _ := ret[0].(*route53resolver.GetFirewallRuleGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallRuleGroupPolicy indicates an expected call of GetFirewallRuleGroupPolicy. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroupPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroupPolicy", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroupPolicy), arg0) +} + +// GetFirewallRuleGroupPolicyRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroupPolicyRequest(arg0 *route53resolver.GetFirewallRuleGroupPolicyInput) (*request.Request, *route53resolver.GetFirewallRuleGroupPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallRuleGroupPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetFirewallRuleGroupPolicyOutput) + return ret0, ret1 +} + +// GetFirewallRuleGroupPolicyRequest indicates an expected call of GetFirewallRuleGroupPolicyRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroupPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroupPolicyRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroupPolicyRequest), arg0) +} + +// GetFirewallRuleGroupPolicyWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroupPolicyWithContext(arg0 aws.Context, arg1 *route53resolver.GetFirewallRuleGroupPolicyInput, arg2 ...request.Option) (*route53resolver.GetFirewallRuleGroupPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetFirewallRuleGroupPolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetFirewallRuleGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallRuleGroupPolicyWithContext indicates an expected call of GetFirewallRuleGroupPolicyWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroupPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroupPolicyWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroupPolicyWithContext), varargs...) +} + +// GetFirewallRuleGroupRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroupRequest(arg0 *route53resolver.GetFirewallRuleGroupInput) (*request.Request, *route53resolver.GetFirewallRuleGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFirewallRuleGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetFirewallRuleGroupOutput) + return ret0, ret1 +} + +// GetFirewallRuleGroupRequest indicates an expected call of GetFirewallRuleGroupRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroupRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroupRequest), arg0) +} + +// GetFirewallRuleGroupWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetFirewallRuleGroupWithContext(arg0 aws.Context, arg1 *route53resolver.GetFirewallRuleGroupInput, arg2 ...request.Option) (*route53resolver.GetFirewallRuleGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetFirewallRuleGroupWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetFirewallRuleGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFirewallRuleGroupWithContext indicates an expected call of GetFirewallRuleGroupWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetFirewallRuleGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirewallRuleGroupWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetFirewallRuleGroupWithContext), varargs...) +} + +// GetOutpostResolver mocks base method. +func (m *MockRoute53ResolverAPI) GetOutpostResolver(arg0 *route53resolver.GetOutpostResolverInput) (*route53resolver.GetOutpostResolverOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOutpostResolver", arg0) + ret0, _ := ret[0].(*route53resolver.GetOutpostResolverOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOutpostResolver indicates an expected call of GetOutpostResolver. +func (mr *MockRoute53ResolverAPIMockRecorder) GetOutpostResolver(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOutpostResolver", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetOutpostResolver), arg0) +} + +// GetOutpostResolverRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetOutpostResolverRequest(arg0 *route53resolver.GetOutpostResolverInput) (*request.Request, *route53resolver.GetOutpostResolverOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOutpostResolverRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetOutpostResolverOutput) + return ret0, ret1 +} + +// GetOutpostResolverRequest indicates an expected call of GetOutpostResolverRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetOutpostResolverRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOutpostResolverRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetOutpostResolverRequest), arg0) +} + +// GetOutpostResolverWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetOutpostResolverWithContext(arg0 aws.Context, arg1 *route53resolver.GetOutpostResolverInput, arg2 ...request.Option) (*route53resolver.GetOutpostResolverOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOutpostResolverWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetOutpostResolverOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOutpostResolverWithContext indicates an expected call of GetOutpostResolverWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetOutpostResolverWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOutpostResolverWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetOutpostResolverWithContext), varargs...) +} + +// GetResolverConfig mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverConfig(arg0 *route53resolver.GetResolverConfigInput) (*route53resolver.GetResolverConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverConfig", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverConfig indicates an expected call of GetResolverConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverConfig), arg0) +} + +// GetResolverConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverConfigRequest(arg0 *route53resolver.GetResolverConfigInput) (*request.Request, *route53resolver.GetResolverConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverConfigOutput) + return ret0, ret1 +} + +// GetResolverConfigRequest indicates an expected call of GetResolverConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverConfigRequest), arg0) +} + +// GetResolverConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverConfigWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverConfigInput, arg2 ...request.Option) (*route53resolver.GetResolverConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverConfigWithContext indicates an expected call of GetResolverConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverConfigWithContext), varargs...) +} + +// GetResolverDnssecConfig mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverDnssecConfig(arg0 *route53resolver.GetResolverDnssecConfigInput) (*route53resolver.GetResolverDnssecConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverDnssecConfig", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverDnssecConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverDnssecConfig indicates an expected call of GetResolverDnssecConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverDnssecConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverDnssecConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverDnssecConfig), arg0) +} + +// GetResolverDnssecConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverDnssecConfigRequest(arg0 *route53resolver.GetResolverDnssecConfigInput) (*request.Request, *route53resolver.GetResolverDnssecConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverDnssecConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverDnssecConfigOutput) + return ret0, ret1 +} + +// GetResolverDnssecConfigRequest indicates an expected call of GetResolverDnssecConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverDnssecConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverDnssecConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverDnssecConfigRequest), arg0) +} + +// GetResolverDnssecConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverDnssecConfigWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverDnssecConfigInput, arg2 ...request.Option) (*route53resolver.GetResolverDnssecConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverDnssecConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverDnssecConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverDnssecConfigWithContext indicates an expected call of GetResolverDnssecConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverDnssecConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverDnssecConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverDnssecConfigWithContext), varargs...) +} + +// GetResolverEndpoint mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverEndpoint(arg0 *route53resolver.GetResolverEndpointInput) (*route53resolver.GetResolverEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverEndpoint", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverEndpoint indicates an expected call of GetResolverEndpoint. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverEndpoint", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverEndpoint), arg0) +} + +// GetResolverEndpointRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverEndpointRequest(arg0 *route53resolver.GetResolverEndpointInput) (*request.Request, *route53resolver.GetResolverEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverEndpointOutput) + return ret0, ret1 +} + +// GetResolverEndpointRequest indicates an expected call of GetResolverEndpointRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverEndpointRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverEndpointRequest), arg0) +} + +// GetResolverEndpointWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverEndpointWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverEndpointInput, arg2 ...request.Option) (*route53resolver.GetResolverEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverEndpointWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverEndpointWithContext indicates an expected call of GetResolverEndpointWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverEndpointWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverEndpointWithContext), varargs...) +} + +// GetResolverQueryLogConfig mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfig(arg0 *route53resolver.GetResolverQueryLogConfigInput) (*route53resolver.GetResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverQueryLogConfig", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverQueryLogConfig indicates an expected call of GetResolverQueryLogConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfig), arg0) +} + +// GetResolverQueryLogConfigAssociation mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfigAssociation(arg0 *route53resolver.GetResolverQueryLogConfigAssociationInput) (*route53resolver.GetResolverQueryLogConfigAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverQueryLogConfigAssociation", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverQueryLogConfigAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverQueryLogConfigAssociation indicates an expected call of GetResolverQueryLogConfigAssociation. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfigAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfigAssociation", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfigAssociation), arg0) +} + +// GetResolverQueryLogConfigAssociationRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfigAssociationRequest(arg0 *route53resolver.GetResolverQueryLogConfigAssociationInput) (*request.Request, *route53resolver.GetResolverQueryLogConfigAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverQueryLogConfigAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverQueryLogConfigAssociationOutput) + return ret0, ret1 +} + +// GetResolverQueryLogConfigAssociationRequest indicates an expected call of GetResolverQueryLogConfigAssociationRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfigAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfigAssociationRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfigAssociationRequest), arg0) +} + +// GetResolverQueryLogConfigAssociationWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfigAssociationWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverQueryLogConfigAssociationInput, arg2 ...request.Option) (*route53resolver.GetResolverQueryLogConfigAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverQueryLogConfigAssociationWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverQueryLogConfigAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverQueryLogConfigAssociationWithContext indicates an expected call of GetResolverQueryLogConfigAssociationWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfigAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfigAssociationWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfigAssociationWithContext), varargs...) +} + +// GetResolverQueryLogConfigPolicy mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfigPolicy(arg0 *route53resolver.GetResolverQueryLogConfigPolicyInput) (*route53resolver.GetResolverQueryLogConfigPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverQueryLogConfigPolicy", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverQueryLogConfigPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverQueryLogConfigPolicy indicates an expected call of GetResolverQueryLogConfigPolicy. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfigPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfigPolicy", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfigPolicy), arg0) +} + +// GetResolverQueryLogConfigPolicyRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfigPolicyRequest(arg0 *route53resolver.GetResolverQueryLogConfigPolicyInput) (*request.Request, *route53resolver.GetResolverQueryLogConfigPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverQueryLogConfigPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverQueryLogConfigPolicyOutput) + return ret0, ret1 +} + +// GetResolverQueryLogConfigPolicyRequest indicates an expected call of GetResolverQueryLogConfigPolicyRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfigPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfigPolicyRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfigPolicyRequest), arg0) +} + +// GetResolverQueryLogConfigPolicyWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfigPolicyWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverQueryLogConfigPolicyInput, arg2 ...request.Option) (*route53resolver.GetResolverQueryLogConfigPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverQueryLogConfigPolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverQueryLogConfigPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverQueryLogConfigPolicyWithContext indicates an expected call of GetResolverQueryLogConfigPolicyWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfigPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfigPolicyWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfigPolicyWithContext), varargs...) +} + +// GetResolverQueryLogConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfigRequest(arg0 *route53resolver.GetResolverQueryLogConfigInput) (*request.Request, *route53resolver.GetResolverQueryLogConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverQueryLogConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverQueryLogConfigOutput) + return ret0, ret1 +} + +// GetResolverQueryLogConfigRequest indicates an expected call of GetResolverQueryLogConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfigRequest), arg0) +} + +// GetResolverQueryLogConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverQueryLogConfigWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverQueryLogConfigInput, arg2 ...request.Option) (*route53resolver.GetResolverQueryLogConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverQueryLogConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverQueryLogConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverQueryLogConfigWithContext indicates an expected call of GetResolverQueryLogConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverQueryLogConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverQueryLogConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverQueryLogConfigWithContext), varargs...) +} + +// GetResolverRule mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRule(arg0 *route53resolver.GetResolverRuleInput) (*route53resolver.GetResolverRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverRule", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverRule indicates an expected call of GetResolverRule. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRule), arg0) +} + +// GetResolverRuleAssociation mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRuleAssociation(arg0 *route53resolver.GetResolverRuleAssociationInput) (*route53resolver.GetResolverRuleAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverRuleAssociation", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverRuleAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverRuleAssociation indicates an expected call of GetResolverRuleAssociation. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRuleAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRuleAssociation", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRuleAssociation), arg0) +} + +// GetResolverRuleAssociationRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRuleAssociationRequest(arg0 *route53resolver.GetResolverRuleAssociationInput) (*request.Request, *route53resolver.GetResolverRuleAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverRuleAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverRuleAssociationOutput) + return ret0, ret1 +} + +// GetResolverRuleAssociationRequest indicates an expected call of GetResolverRuleAssociationRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRuleAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRuleAssociationRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRuleAssociationRequest), arg0) +} + +// GetResolverRuleAssociationWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRuleAssociationWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverRuleAssociationInput, arg2 ...request.Option) (*route53resolver.GetResolverRuleAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverRuleAssociationWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverRuleAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverRuleAssociationWithContext indicates an expected call of GetResolverRuleAssociationWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRuleAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRuleAssociationWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRuleAssociationWithContext), varargs...) +} + +// GetResolverRulePolicy mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRulePolicy(arg0 *route53resolver.GetResolverRulePolicyInput) (*route53resolver.GetResolverRulePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverRulePolicy", arg0) + ret0, _ := ret[0].(*route53resolver.GetResolverRulePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverRulePolicy indicates an expected call of GetResolverRulePolicy. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRulePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRulePolicy", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRulePolicy), arg0) +} + +// GetResolverRulePolicyRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRulePolicyRequest(arg0 *route53resolver.GetResolverRulePolicyInput) (*request.Request, *route53resolver.GetResolverRulePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverRulePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverRulePolicyOutput) + return ret0, ret1 +} + +// GetResolverRulePolicyRequest indicates an expected call of GetResolverRulePolicyRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRulePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRulePolicyRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRulePolicyRequest), arg0) +} + +// GetResolverRulePolicyWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRulePolicyWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverRulePolicyInput, arg2 ...request.Option) (*route53resolver.GetResolverRulePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverRulePolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverRulePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverRulePolicyWithContext indicates an expected call of GetResolverRulePolicyWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRulePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRulePolicyWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRulePolicyWithContext), varargs...) +} + +// GetResolverRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRuleRequest(arg0 *route53resolver.GetResolverRuleInput) (*request.Request, *route53resolver.GetResolverRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResolverRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.GetResolverRuleOutput) + return ret0, ret1 +} + +// GetResolverRuleRequest indicates an expected call of GetResolverRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRuleRequest), arg0) +} + +// GetResolverRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) GetResolverRuleWithContext(arg0 aws.Context, arg1 *route53resolver.GetResolverRuleInput, arg2 ...request.Option) (*route53resolver.GetResolverRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResolverRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.GetResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResolverRuleWithContext indicates an expected call of GetResolverRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) GetResolverRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolverRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).GetResolverRuleWithContext), varargs...) +} + +// ImportFirewallDomains mocks base method. +func (m *MockRoute53ResolverAPI) ImportFirewallDomains(arg0 *route53resolver.ImportFirewallDomainsInput) (*route53resolver.ImportFirewallDomainsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportFirewallDomains", arg0) + ret0, _ := ret[0].(*route53resolver.ImportFirewallDomainsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportFirewallDomains indicates an expected call of ImportFirewallDomains. +func (mr *MockRoute53ResolverAPIMockRecorder) ImportFirewallDomains(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportFirewallDomains", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ImportFirewallDomains), arg0) +} + +// ImportFirewallDomainsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ImportFirewallDomainsRequest(arg0 *route53resolver.ImportFirewallDomainsInput) (*request.Request, *route53resolver.ImportFirewallDomainsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportFirewallDomainsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ImportFirewallDomainsOutput) + return ret0, ret1 +} + +// ImportFirewallDomainsRequest indicates an expected call of ImportFirewallDomainsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ImportFirewallDomainsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportFirewallDomainsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ImportFirewallDomainsRequest), arg0) +} + +// ImportFirewallDomainsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ImportFirewallDomainsWithContext(arg0 aws.Context, arg1 *route53resolver.ImportFirewallDomainsInput, arg2 ...request.Option) (*route53resolver.ImportFirewallDomainsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportFirewallDomainsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ImportFirewallDomainsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportFirewallDomainsWithContext indicates an expected call of ImportFirewallDomainsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ImportFirewallDomainsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportFirewallDomainsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ImportFirewallDomainsWithContext), varargs...) +} + +// ListFirewallConfigs mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallConfigs(arg0 *route53resolver.ListFirewallConfigsInput) (*route53resolver.ListFirewallConfigsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallConfigs", arg0) + ret0, _ := ret[0].(*route53resolver.ListFirewallConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallConfigs indicates an expected call of ListFirewallConfigs. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallConfigs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallConfigs", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallConfigs), arg0) +} + +// ListFirewallConfigsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallConfigsPages(arg0 *route53resolver.ListFirewallConfigsInput, arg1 func(*route53resolver.ListFirewallConfigsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallConfigsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallConfigsPages indicates an expected call of ListFirewallConfigsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallConfigsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallConfigsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallConfigsPages), arg0, arg1) +} + +// ListFirewallConfigsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallConfigsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallConfigsInput, arg2 func(*route53resolver.ListFirewallConfigsOutput, 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, "ListFirewallConfigsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallConfigsPagesWithContext indicates an expected call of ListFirewallConfigsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallConfigsPagesWithContext(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, "ListFirewallConfigsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallConfigsPagesWithContext), varargs...) +} + +// ListFirewallConfigsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallConfigsRequest(arg0 *route53resolver.ListFirewallConfigsInput) (*request.Request, *route53resolver.ListFirewallConfigsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallConfigsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListFirewallConfigsOutput) + return ret0, ret1 +} + +// ListFirewallConfigsRequest indicates an expected call of ListFirewallConfigsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallConfigsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallConfigsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallConfigsRequest), arg0) +} + +// ListFirewallConfigsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallConfigsWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallConfigsInput, arg2 ...request.Option) (*route53resolver.ListFirewallConfigsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFirewallConfigsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListFirewallConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallConfigsWithContext indicates an expected call of ListFirewallConfigsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallConfigsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallConfigsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallConfigsWithContext), varargs...) +} + +// ListFirewallDomainLists mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainLists(arg0 *route53resolver.ListFirewallDomainListsInput) (*route53resolver.ListFirewallDomainListsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallDomainLists", arg0) + ret0, _ := ret[0].(*route53resolver.ListFirewallDomainListsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallDomainLists indicates an expected call of ListFirewallDomainLists. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainLists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallDomainLists", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainLists), arg0) +} + +// ListFirewallDomainListsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainListsPages(arg0 *route53resolver.ListFirewallDomainListsInput, arg1 func(*route53resolver.ListFirewallDomainListsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallDomainListsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallDomainListsPages indicates an expected call of ListFirewallDomainListsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainListsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallDomainListsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainListsPages), arg0, arg1) +} + +// ListFirewallDomainListsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainListsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallDomainListsInput, arg2 func(*route53resolver.ListFirewallDomainListsOutput, 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, "ListFirewallDomainListsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallDomainListsPagesWithContext indicates an expected call of ListFirewallDomainListsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainListsPagesWithContext(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, "ListFirewallDomainListsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainListsPagesWithContext), varargs...) +} + +// ListFirewallDomainListsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainListsRequest(arg0 *route53resolver.ListFirewallDomainListsInput) (*request.Request, *route53resolver.ListFirewallDomainListsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallDomainListsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListFirewallDomainListsOutput) + return ret0, ret1 +} + +// ListFirewallDomainListsRequest indicates an expected call of ListFirewallDomainListsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainListsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallDomainListsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainListsRequest), arg0) +} + +// ListFirewallDomainListsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainListsWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallDomainListsInput, arg2 ...request.Option) (*route53resolver.ListFirewallDomainListsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFirewallDomainListsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListFirewallDomainListsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallDomainListsWithContext indicates an expected call of ListFirewallDomainListsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainListsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallDomainListsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainListsWithContext), varargs...) +} + +// ListFirewallDomains mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomains(arg0 *route53resolver.ListFirewallDomainsInput) (*route53resolver.ListFirewallDomainsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallDomains", arg0) + ret0, _ := ret[0].(*route53resolver.ListFirewallDomainsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallDomains indicates an expected call of ListFirewallDomains. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomains(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallDomains", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomains), arg0) +} + +// ListFirewallDomainsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainsPages(arg0 *route53resolver.ListFirewallDomainsInput, arg1 func(*route53resolver.ListFirewallDomainsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallDomainsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallDomainsPages indicates an expected call of ListFirewallDomainsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallDomainsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainsPages), arg0, arg1) +} + +// ListFirewallDomainsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallDomainsInput, arg2 func(*route53resolver.ListFirewallDomainsOutput, 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, "ListFirewallDomainsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallDomainsPagesWithContext indicates an expected call of ListFirewallDomainsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainsPagesWithContext(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, "ListFirewallDomainsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainsPagesWithContext), varargs...) +} + +// ListFirewallDomainsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainsRequest(arg0 *route53resolver.ListFirewallDomainsInput) (*request.Request, *route53resolver.ListFirewallDomainsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallDomainsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListFirewallDomainsOutput) + return ret0, ret1 +} + +// ListFirewallDomainsRequest indicates an expected call of ListFirewallDomainsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallDomainsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainsRequest), arg0) +} + +// ListFirewallDomainsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallDomainsWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallDomainsInput, arg2 ...request.Option) (*route53resolver.ListFirewallDomainsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFirewallDomainsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListFirewallDomainsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallDomainsWithContext indicates an expected call of ListFirewallDomainsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallDomainsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallDomainsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallDomainsWithContext), varargs...) +} + +// ListFirewallRuleGroupAssociations mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupAssociations(arg0 *route53resolver.ListFirewallRuleGroupAssociationsInput) (*route53resolver.ListFirewallRuleGroupAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRuleGroupAssociations", arg0) + ret0, _ := ret[0].(*route53resolver.ListFirewallRuleGroupAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallRuleGroupAssociations indicates an expected call of ListFirewallRuleGroupAssociations. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRuleGroupAssociations", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupAssociations), arg0) +} + +// ListFirewallRuleGroupAssociationsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupAssociationsPages(arg0 *route53resolver.ListFirewallRuleGroupAssociationsInput, arg1 func(*route53resolver.ListFirewallRuleGroupAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRuleGroupAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallRuleGroupAssociationsPages indicates an expected call of ListFirewallRuleGroupAssociationsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRuleGroupAssociationsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupAssociationsPages), arg0, arg1) +} + +// ListFirewallRuleGroupAssociationsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupAssociationsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallRuleGroupAssociationsInput, arg2 func(*route53resolver.ListFirewallRuleGroupAssociationsOutput, 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, "ListFirewallRuleGroupAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallRuleGroupAssociationsPagesWithContext indicates an expected call of ListFirewallRuleGroupAssociationsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupAssociationsPagesWithContext(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, "ListFirewallRuleGroupAssociationsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupAssociationsPagesWithContext), varargs...) +} + +// ListFirewallRuleGroupAssociationsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupAssociationsRequest(arg0 *route53resolver.ListFirewallRuleGroupAssociationsInput) (*request.Request, *route53resolver.ListFirewallRuleGroupAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRuleGroupAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListFirewallRuleGroupAssociationsOutput) + return ret0, ret1 +} + +// ListFirewallRuleGroupAssociationsRequest indicates an expected call of ListFirewallRuleGroupAssociationsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRuleGroupAssociationsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupAssociationsRequest), arg0) +} + +// ListFirewallRuleGroupAssociationsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupAssociationsWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallRuleGroupAssociationsInput, arg2 ...request.Option) (*route53resolver.ListFirewallRuleGroupAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFirewallRuleGroupAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListFirewallRuleGroupAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallRuleGroupAssociationsWithContext indicates an expected call of ListFirewallRuleGroupAssociationsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRuleGroupAssociationsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupAssociationsWithContext), varargs...) +} + +// ListFirewallRuleGroups mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroups(arg0 *route53resolver.ListFirewallRuleGroupsInput) (*route53resolver.ListFirewallRuleGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRuleGroups", arg0) + ret0, _ := ret[0].(*route53resolver.ListFirewallRuleGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallRuleGroups indicates an expected call of ListFirewallRuleGroups. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRuleGroups", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroups), arg0) +} + +// ListFirewallRuleGroupsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupsPages(arg0 *route53resolver.ListFirewallRuleGroupsInput, arg1 func(*route53resolver.ListFirewallRuleGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRuleGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallRuleGroupsPages indicates an expected call of ListFirewallRuleGroupsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRuleGroupsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupsPages), arg0, arg1) +} + +// ListFirewallRuleGroupsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallRuleGroupsInput, arg2 func(*route53resolver.ListFirewallRuleGroupsOutput, 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, "ListFirewallRuleGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallRuleGroupsPagesWithContext indicates an expected call of ListFirewallRuleGroupsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupsPagesWithContext(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, "ListFirewallRuleGroupsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupsPagesWithContext), varargs...) +} + +// ListFirewallRuleGroupsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupsRequest(arg0 *route53resolver.ListFirewallRuleGroupsInput) (*request.Request, *route53resolver.ListFirewallRuleGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRuleGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListFirewallRuleGroupsOutput) + return ret0, ret1 +} + +// ListFirewallRuleGroupsRequest indicates an expected call of ListFirewallRuleGroupsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRuleGroupsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupsRequest), arg0) +} + +// ListFirewallRuleGroupsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRuleGroupsWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallRuleGroupsInput, arg2 ...request.Option) (*route53resolver.ListFirewallRuleGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFirewallRuleGroupsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListFirewallRuleGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallRuleGroupsWithContext indicates an expected call of ListFirewallRuleGroupsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRuleGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRuleGroupsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRuleGroupsWithContext), varargs...) +} + +// ListFirewallRules mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRules(arg0 *route53resolver.ListFirewallRulesInput) (*route53resolver.ListFirewallRulesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRules", arg0) + ret0, _ := ret[0].(*route53resolver.ListFirewallRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallRules indicates an expected call of ListFirewallRules. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRules(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRules", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRules), arg0) +} + +// ListFirewallRulesPages mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRulesPages(arg0 *route53resolver.ListFirewallRulesInput, arg1 func(*route53resolver.ListFirewallRulesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRulesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallRulesPages indicates an expected call of ListFirewallRulesPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRulesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRulesPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRulesPages), arg0, arg1) +} + +// ListFirewallRulesPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRulesPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallRulesInput, arg2 func(*route53resolver.ListFirewallRulesOutput, 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, "ListFirewallRulesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFirewallRulesPagesWithContext indicates an expected call of ListFirewallRulesPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRulesPagesWithContext(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, "ListFirewallRulesPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRulesPagesWithContext), varargs...) +} + +// ListFirewallRulesRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRulesRequest(arg0 *route53resolver.ListFirewallRulesInput) (*request.Request, *route53resolver.ListFirewallRulesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFirewallRulesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListFirewallRulesOutput) + return ret0, ret1 +} + +// ListFirewallRulesRequest indicates an expected call of ListFirewallRulesRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRulesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRulesRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRulesRequest), arg0) +} + +// ListFirewallRulesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListFirewallRulesWithContext(arg0 aws.Context, arg1 *route53resolver.ListFirewallRulesInput, arg2 ...request.Option) (*route53resolver.ListFirewallRulesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFirewallRulesWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListFirewallRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFirewallRulesWithContext indicates an expected call of ListFirewallRulesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListFirewallRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFirewallRulesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListFirewallRulesWithContext), varargs...) +} + +// ListOutpostResolvers mocks base method. +func (m *MockRoute53ResolverAPI) ListOutpostResolvers(arg0 *route53resolver.ListOutpostResolversInput) (*route53resolver.ListOutpostResolversOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListOutpostResolvers", arg0) + ret0, _ := ret[0].(*route53resolver.ListOutpostResolversOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListOutpostResolvers indicates an expected call of ListOutpostResolvers. +func (mr *MockRoute53ResolverAPIMockRecorder) ListOutpostResolvers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOutpostResolvers", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListOutpostResolvers), arg0) +} + +// ListOutpostResolversPages mocks base method. +func (m *MockRoute53ResolverAPI) ListOutpostResolversPages(arg0 *route53resolver.ListOutpostResolversInput, arg1 func(*route53resolver.ListOutpostResolversOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListOutpostResolversPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListOutpostResolversPages indicates an expected call of ListOutpostResolversPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListOutpostResolversPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOutpostResolversPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListOutpostResolversPages), arg0, arg1) +} + +// ListOutpostResolversPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListOutpostResolversPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListOutpostResolversInput, arg2 func(*route53resolver.ListOutpostResolversOutput, 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, "ListOutpostResolversPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListOutpostResolversPagesWithContext indicates an expected call of ListOutpostResolversPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListOutpostResolversPagesWithContext(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, "ListOutpostResolversPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListOutpostResolversPagesWithContext), varargs...) +} + +// ListOutpostResolversRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListOutpostResolversRequest(arg0 *route53resolver.ListOutpostResolversInput) (*request.Request, *route53resolver.ListOutpostResolversOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListOutpostResolversRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListOutpostResolversOutput) + return ret0, ret1 +} + +// ListOutpostResolversRequest indicates an expected call of ListOutpostResolversRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListOutpostResolversRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOutpostResolversRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListOutpostResolversRequest), arg0) +} + +// ListOutpostResolversWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListOutpostResolversWithContext(arg0 aws.Context, arg1 *route53resolver.ListOutpostResolversInput, arg2 ...request.Option) (*route53resolver.ListOutpostResolversOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListOutpostResolversWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListOutpostResolversOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListOutpostResolversWithContext indicates an expected call of ListOutpostResolversWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListOutpostResolversWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOutpostResolversWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListOutpostResolversWithContext), varargs...) +} + +// ListResolverConfigs mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverConfigs(arg0 *route53resolver.ListResolverConfigsInput) (*route53resolver.ListResolverConfigsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverConfigs", arg0) + ret0, _ := ret[0].(*route53resolver.ListResolverConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverConfigs indicates an expected call of ListResolverConfigs. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverConfigs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverConfigs", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverConfigs), arg0) +} + +// ListResolverConfigsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverConfigsPages(arg0 *route53resolver.ListResolverConfigsInput, arg1 func(*route53resolver.ListResolverConfigsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverConfigsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverConfigsPages indicates an expected call of ListResolverConfigsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverConfigsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverConfigsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverConfigsPages), arg0, arg1) +} + +// ListResolverConfigsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverConfigsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverConfigsInput, arg2 func(*route53resolver.ListResolverConfigsOutput, 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, "ListResolverConfigsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverConfigsPagesWithContext indicates an expected call of ListResolverConfigsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverConfigsPagesWithContext(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, "ListResolverConfigsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverConfigsPagesWithContext), varargs...) +} + +// ListResolverConfigsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverConfigsRequest(arg0 *route53resolver.ListResolverConfigsInput) (*request.Request, *route53resolver.ListResolverConfigsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverConfigsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListResolverConfigsOutput) + return ret0, ret1 +} + +// ListResolverConfigsRequest indicates an expected call of ListResolverConfigsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverConfigsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverConfigsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverConfigsRequest), arg0) +} + +// ListResolverConfigsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverConfigsWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverConfigsInput, arg2 ...request.Option) (*route53resolver.ListResolverConfigsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResolverConfigsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListResolverConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverConfigsWithContext indicates an expected call of ListResolverConfigsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverConfigsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverConfigsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverConfigsWithContext), varargs...) +} + +// ListResolverDnssecConfigs mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverDnssecConfigs(arg0 *route53resolver.ListResolverDnssecConfigsInput) (*route53resolver.ListResolverDnssecConfigsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverDnssecConfigs", arg0) + ret0, _ := ret[0].(*route53resolver.ListResolverDnssecConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverDnssecConfigs indicates an expected call of ListResolverDnssecConfigs. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverDnssecConfigs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverDnssecConfigs", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverDnssecConfigs), arg0) +} + +// ListResolverDnssecConfigsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverDnssecConfigsPages(arg0 *route53resolver.ListResolverDnssecConfigsInput, arg1 func(*route53resolver.ListResolverDnssecConfigsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverDnssecConfigsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverDnssecConfigsPages indicates an expected call of ListResolverDnssecConfigsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverDnssecConfigsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverDnssecConfigsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverDnssecConfigsPages), arg0, arg1) +} + +// ListResolverDnssecConfigsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverDnssecConfigsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverDnssecConfigsInput, arg2 func(*route53resolver.ListResolverDnssecConfigsOutput, 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, "ListResolverDnssecConfigsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverDnssecConfigsPagesWithContext indicates an expected call of ListResolverDnssecConfigsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverDnssecConfigsPagesWithContext(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, "ListResolverDnssecConfigsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverDnssecConfigsPagesWithContext), varargs...) +} + +// ListResolverDnssecConfigsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverDnssecConfigsRequest(arg0 *route53resolver.ListResolverDnssecConfigsInput) (*request.Request, *route53resolver.ListResolverDnssecConfigsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverDnssecConfigsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListResolverDnssecConfigsOutput) + return ret0, ret1 +} + +// ListResolverDnssecConfigsRequest indicates an expected call of ListResolverDnssecConfigsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverDnssecConfigsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverDnssecConfigsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverDnssecConfigsRequest), arg0) +} + +// ListResolverDnssecConfigsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverDnssecConfigsWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverDnssecConfigsInput, arg2 ...request.Option) (*route53resolver.ListResolverDnssecConfigsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResolverDnssecConfigsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListResolverDnssecConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverDnssecConfigsWithContext indicates an expected call of ListResolverDnssecConfigsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverDnssecConfigsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverDnssecConfigsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverDnssecConfigsWithContext), varargs...) +} + +// ListResolverEndpointIpAddresses mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointIpAddresses(arg0 *route53resolver.ListResolverEndpointIpAddressesInput) (*route53resolver.ListResolverEndpointIpAddressesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverEndpointIpAddresses", arg0) + ret0, _ := ret[0].(*route53resolver.ListResolverEndpointIpAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverEndpointIpAddresses indicates an expected call of ListResolverEndpointIpAddresses. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointIpAddresses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverEndpointIpAddresses", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointIpAddresses), arg0) +} + +// ListResolverEndpointIpAddressesPages mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointIpAddressesPages(arg0 *route53resolver.ListResolverEndpointIpAddressesInput, arg1 func(*route53resolver.ListResolverEndpointIpAddressesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverEndpointIpAddressesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverEndpointIpAddressesPages indicates an expected call of ListResolverEndpointIpAddressesPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointIpAddressesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverEndpointIpAddressesPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointIpAddressesPages), arg0, arg1) +} + +// ListResolverEndpointIpAddressesPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointIpAddressesPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverEndpointIpAddressesInput, arg2 func(*route53resolver.ListResolverEndpointIpAddressesOutput, 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, "ListResolverEndpointIpAddressesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverEndpointIpAddressesPagesWithContext indicates an expected call of ListResolverEndpointIpAddressesPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointIpAddressesPagesWithContext(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, "ListResolverEndpointIpAddressesPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointIpAddressesPagesWithContext), varargs...) +} + +// ListResolverEndpointIpAddressesRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointIpAddressesRequest(arg0 *route53resolver.ListResolverEndpointIpAddressesInput) (*request.Request, *route53resolver.ListResolverEndpointIpAddressesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverEndpointIpAddressesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListResolverEndpointIpAddressesOutput) + return ret0, ret1 +} + +// ListResolverEndpointIpAddressesRequest indicates an expected call of ListResolverEndpointIpAddressesRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointIpAddressesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverEndpointIpAddressesRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointIpAddressesRequest), arg0) +} + +// ListResolverEndpointIpAddressesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointIpAddressesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverEndpointIpAddressesInput, arg2 ...request.Option) (*route53resolver.ListResolverEndpointIpAddressesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResolverEndpointIpAddressesWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListResolverEndpointIpAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverEndpointIpAddressesWithContext indicates an expected call of ListResolverEndpointIpAddressesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointIpAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverEndpointIpAddressesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointIpAddressesWithContext), varargs...) +} + +// ListResolverEndpoints mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpoints(arg0 *route53resolver.ListResolverEndpointsInput) (*route53resolver.ListResolverEndpointsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverEndpoints", arg0) + ret0, _ := ret[0].(*route53resolver.ListResolverEndpointsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverEndpoints indicates an expected call of ListResolverEndpoints. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpoints(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverEndpoints", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpoints), arg0) +} + +// ListResolverEndpointsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointsPages(arg0 *route53resolver.ListResolverEndpointsInput, arg1 func(*route53resolver.ListResolverEndpointsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverEndpointsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverEndpointsPages indicates an expected call of ListResolverEndpointsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverEndpointsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointsPages), arg0, arg1) +} + +// ListResolverEndpointsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverEndpointsInput, arg2 func(*route53resolver.ListResolverEndpointsOutput, 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, "ListResolverEndpointsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverEndpointsPagesWithContext indicates an expected call of ListResolverEndpointsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointsPagesWithContext(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, "ListResolverEndpointsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointsPagesWithContext), varargs...) +} + +// ListResolverEndpointsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointsRequest(arg0 *route53resolver.ListResolverEndpointsInput) (*request.Request, *route53resolver.ListResolverEndpointsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverEndpointsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListResolverEndpointsOutput) + return ret0, ret1 +} + +// ListResolverEndpointsRequest indicates an expected call of ListResolverEndpointsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverEndpointsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointsRequest), arg0) +} + +// ListResolverEndpointsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverEndpointsWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverEndpointsInput, arg2 ...request.Option) (*route53resolver.ListResolverEndpointsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResolverEndpointsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListResolverEndpointsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverEndpointsWithContext indicates an expected call of ListResolverEndpointsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverEndpointsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverEndpointsWithContext), varargs...) +} + +// ListResolverQueryLogConfigAssociations mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigAssociations(arg0 *route53resolver.ListResolverQueryLogConfigAssociationsInput) (*route53resolver.ListResolverQueryLogConfigAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverQueryLogConfigAssociations", arg0) + ret0, _ := ret[0].(*route53resolver.ListResolverQueryLogConfigAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverQueryLogConfigAssociations indicates an expected call of ListResolverQueryLogConfigAssociations. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverQueryLogConfigAssociations", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigAssociations), arg0) +} + +// ListResolverQueryLogConfigAssociationsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigAssociationsPages(arg0 *route53resolver.ListResolverQueryLogConfigAssociationsInput, arg1 func(*route53resolver.ListResolverQueryLogConfigAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverQueryLogConfigAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverQueryLogConfigAssociationsPages indicates an expected call of ListResolverQueryLogConfigAssociationsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverQueryLogConfigAssociationsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigAssociationsPages), arg0, arg1) +} + +// ListResolverQueryLogConfigAssociationsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigAssociationsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverQueryLogConfigAssociationsInput, arg2 func(*route53resolver.ListResolverQueryLogConfigAssociationsOutput, 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, "ListResolverQueryLogConfigAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverQueryLogConfigAssociationsPagesWithContext indicates an expected call of ListResolverQueryLogConfigAssociationsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigAssociationsPagesWithContext(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, "ListResolverQueryLogConfigAssociationsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigAssociationsPagesWithContext), varargs...) +} + +// ListResolverQueryLogConfigAssociationsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigAssociationsRequest(arg0 *route53resolver.ListResolverQueryLogConfigAssociationsInput) (*request.Request, *route53resolver.ListResolverQueryLogConfigAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverQueryLogConfigAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListResolverQueryLogConfigAssociationsOutput) + return ret0, ret1 +} + +// ListResolverQueryLogConfigAssociationsRequest indicates an expected call of ListResolverQueryLogConfigAssociationsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverQueryLogConfigAssociationsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigAssociationsRequest), arg0) +} + +// ListResolverQueryLogConfigAssociationsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigAssociationsWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverQueryLogConfigAssociationsInput, arg2 ...request.Option) (*route53resolver.ListResolverQueryLogConfigAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResolverQueryLogConfigAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListResolverQueryLogConfigAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverQueryLogConfigAssociationsWithContext indicates an expected call of ListResolverQueryLogConfigAssociationsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverQueryLogConfigAssociationsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigAssociationsWithContext), varargs...) +} + +// ListResolverQueryLogConfigs mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigs(arg0 *route53resolver.ListResolverQueryLogConfigsInput) (*route53resolver.ListResolverQueryLogConfigsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverQueryLogConfigs", arg0) + ret0, _ := ret[0].(*route53resolver.ListResolverQueryLogConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverQueryLogConfigs indicates an expected call of ListResolverQueryLogConfigs. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverQueryLogConfigs", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigs), arg0) +} + +// ListResolverQueryLogConfigsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigsPages(arg0 *route53resolver.ListResolverQueryLogConfigsInput, arg1 func(*route53resolver.ListResolverQueryLogConfigsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverQueryLogConfigsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverQueryLogConfigsPages indicates an expected call of ListResolverQueryLogConfigsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverQueryLogConfigsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigsPages), arg0, arg1) +} + +// ListResolverQueryLogConfigsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverQueryLogConfigsInput, arg2 func(*route53resolver.ListResolverQueryLogConfigsOutput, 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, "ListResolverQueryLogConfigsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverQueryLogConfigsPagesWithContext indicates an expected call of ListResolverQueryLogConfigsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigsPagesWithContext(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, "ListResolverQueryLogConfigsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigsPagesWithContext), varargs...) +} + +// ListResolverQueryLogConfigsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigsRequest(arg0 *route53resolver.ListResolverQueryLogConfigsInput) (*request.Request, *route53resolver.ListResolverQueryLogConfigsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverQueryLogConfigsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListResolverQueryLogConfigsOutput) + return ret0, ret1 +} + +// ListResolverQueryLogConfigsRequest indicates an expected call of ListResolverQueryLogConfigsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverQueryLogConfigsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigsRequest), arg0) +} + +// ListResolverQueryLogConfigsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverQueryLogConfigsWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverQueryLogConfigsInput, arg2 ...request.Option) (*route53resolver.ListResolverQueryLogConfigsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResolverQueryLogConfigsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListResolverQueryLogConfigsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverQueryLogConfigsWithContext indicates an expected call of ListResolverQueryLogConfigsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverQueryLogConfigsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverQueryLogConfigsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverQueryLogConfigsWithContext), varargs...) +} + +// ListResolverRuleAssociations mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRuleAssociations(arg0 *route53resolver.ListResolverRuleAssociationsInput) (*route53resolver.ListResolverRuleAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverRuleAssociations", arg0) + ret0, _ := ret[0].(*route53resolver.ListResolverRuleAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverRuleAssociations indicates an expected call of ListResolverRuleAssociations. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRuleAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverRuleAssociations", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRuleAssociations), arg0) +} + +// ListResolverRuleAssociationsPages mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRuleAssociationsPages(arg0 *route53resolver.ListResolverRuleAssociationsInput, arg1 func(*route53resolver.ListResolverRuleAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverRuleAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverRuleAssociationsPages indicates an expected call of ListResolverRuleAssociationsPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRuleAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverRuleAssociationsPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRuleAssociationsPages), arg0, arg1) +} + +// ListResolverRuleAssociationsPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRuleAssociationsPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverRuleAssociationsInput, arg2 func(*route53resolver.ListResolverRuleAssociationsOutput, 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, "ListResolverRuleAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverRuleAssociationsPagesWithContext indicates an expected call of ListResolverRuleAssociationsPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRuleAssociationsPagesWithContext(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, "ListResolverRuleAssociationsPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRuleAssociationsPagesWithContext), varargs...) +} + +// ListResolverRuleAssociationsRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRuleAssociationsRequest(arg0 *route53resolver.ListResolverRuleAssociationsInput) (*request.Request, *route53resolver.ListResolverRuleAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverRuleAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListResolverRuleAssociationsOutput) + return ret0, ret1 +} + +// ListResolverRuleAssociationsRequest indicates an expected call of ListResolverRuleAssociationsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRuleAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverRuleAssociationsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRuleAssociationsRequest), arg0) +} + +// ListResolverRuleAssociationsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRuleAssociationsWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverRuleAssociationsInput, arg2 ...request.Option) (*route53resolver.ListResolverRuleAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResolverRuleAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListResolverRuleAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverRuleAssociationsWithContext indicates an expected call of ListResolverRuleAssociationsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRuleAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverRuleAssociationsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRuleAssociationsWithContext), varargs...) +} + +// ListResolverRules mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRules(arg0 *route53resolver.ListResolverRulesInput) (*route53resolver.ListResolverRulesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverRules", arg0) + ret0, _ := ret[0].(*route53resolver.ListResolverRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverRules indicates an expected call of ListResolverRules. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRules(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverRules", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRules), arg0) +} + +// ListResolverRulesPages mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRulesPages(arg0 *route53resolver.ListResolverRulesInput, arg1 func(*route53resolver.ListResolverRulesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverRulesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverRulesPages indicates an expected call of ListResolverRulesPages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRulesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverRulesPages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRulesPages), arg0, arg1) +} + +// ListResolverRulesPagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRulesPagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverRulesInput, arg2 func(*route53resolver.ListResolverRulesOutput, 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, "ListResolverRulesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResolverRulesPagesWithContext indicates an expected call of ListResolverRulesPagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRulesPagesWithContext(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, "ListResolverRulesPagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRulesPagesWithContext), varargs...) +} + +// ListResolverRulesRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRulesRequest(arg0 *route53resolver.ListResolverRulesInput) (*request.Request, *route53resolver.ListResolverRulesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResolverRulesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListResolverRulesOutput) + return ret0, ret1 +} + +// ListResolverRulesRequest indicates an expected call of ListResolverRulesRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRulesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverRulesRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRulesRequest), arg0) +} + +// ListResolverRulesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListResolverRulesWithContext(arg0 aws.Context, arg1 *route53resolver.ListResolverRulesInput, arg2 ...request.Option) (*route53resolver.ListResolverRulesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResolverRulesWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.ListResolverRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResolverRulesWithContext indicates an expected call of ListResolverRulesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListResolverRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResolverRulesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListResolverRulesWithContext), varargs...) +} + +// ListTagsForResource mocks base method. +func (m *MockRoute53ResolverAPI) ListTagsForResource(arg0 *route53resolver.ListTagsForResourceInput) (*route53resolver.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResource", arg0) + ret0, _ := ret[0].(*route53resolver.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResource indicates an expected call of ListTagsForResource. +func (mr *MockRoute53ResolverAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListTagsForResource), arg0) +} + +// ListTagsForResourcePages mocks base method. +func (m *MockRoute53ResolverAPI) ListTagsForResourcePages(arg0 *route53resolver.ListTagsForResourceInput, arg1 func(*route53resolver.ListTagsForResourceOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourcePages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTagsForResourcePages indicates an expected call of ListTagsForResourcePages. +func (mr *MockRoute53ResolverAPIMockRecorder) ListTagsForResourcePages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcePages", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListTagsForResourcePages), arg0, arg1) +} + +// ListTagsForResourcePagesWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListTagsForResourcePagesWithContext(arg0 aws.Context, arg1 *route53resolver.ListTagsForResourceInput, arg2 func(*route53resolver.ListTagsForResourceOutput, 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, "ListTagsForResourcePagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTagsForResourcePagesWithContext indicates an expected call of ListTagsForResourcePagesWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) ListTagsForResourcePagesWithContext(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, "ListTagsForResourcePagesWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListTagsForResourcePagesWithContext), varargs...) +} + +// ListTagsForResourceRequest mocks base method. +func (m *MockRoute53ResolverAPI) ListTagsForResourceRequest(arg0 *route53resolver.ListTagsForResourceInput) (*request.Request, *route53resolver.ListTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.ListTagsForResourceOutput) + return ret0, ret1 +} + +// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).ListTagsForResourceRequest), arg0) +} + +// ListTagsForResourceWithContext mocks base method. +func (m *MockRoute53ResolverAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *route53resolver.ListTagsForResourceInput, arg2 ...request.Option) (*route53resolver.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].(*route53resolver.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) 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((*MockRoute53ResolverAPI)(nil).ListTagsForResourceWithContext), varargs...) +} + +// PutFirewallRuleGroupPolicy mocks base method. +func (m *MockRoute53ResolverAPI) PutFirewallRuleGroupPolicy(arg0 *route53resolver.PutFirewallRuleGroupPolicyInput) (*route53resolver.PutFirewallRuleGroupPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutFirewallRuleGroupPolicy", arg0) + ret0, _ := ret[0].(*route53resolver.PutFirewallRuleGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutFirewallRuleGroupPolicy indicates an expected call of PutFirewallRuleGroupPolicy. +func (mr *MockRoute53ResolverAPIMockRecorder) PutFirewallRuleGroupPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutFirewallRuleGroupPolicy", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutFirewallRuleGroupPolicy), arg0) +} + +// PutFirewallRuleGroupPolicyRequest mocks base method. +func (m *MockRoute53ResolverAPI) PutFirewallRuleGroupPolicyRequest(arg0 *route53resolver.PutFirewallRuleGroupPolicyInput) (*request.Request, *route53resolver.PutFirewallRuleGroupPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutFirewallRuleGroupPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.PutFirewallRuleGroupPolicyOutput) + return ret0, ret1 +} + +// PutFirewallRuleGroupPolicyRequest indicates an expected call of PutFirewallRuleGroupPolicyRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) PutFirewallRuleGroupPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutFirewallRuleGroupPolicyRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutFirewallRuleGroupPolicyRequest), arg0) +} + +// PutFirewallRuleGroupPolicyWithContext mocks base method. +func (m *MockRoute53ResolverAPI) PutFirewallRuleGroupPolicyWithContext(arg0 aws.Context, arg1 *route53resolver.PutFirewallRuleGroupPolicyInput, arg2 ...request.Option) (*route53resolver.PutFirewallRuleGroupPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutFirewallRuleGroupPolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.PutFirewallRuleGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutFirewallRuleGroupPolicyWithContext indicates an expected call of PutFirewallRuleGroupPolicyWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) PutFirewallRuleGroupPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutFirewallRuleGroupPolicyWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutFirewallRuleGroupPolicyWithContext), varargs...) +} + +// PutResolverQueryLogConfigPolicy mocks base method. +func (m *MockRoute53ResolverAPI) PutResolverQueryLogConfigPolicy(arg0 *route53resolver.PutResolverQueryLogConfigPolicyInput) (*route53resolver.PutResolverQueryLogConfigPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutResolverQueryLogConfigPolicy", arg0) + ret0, _ := ret[0].(*route53resolver.PutResolverQueryLogConfigPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutResolverQueryLogConfigPolicy indicates an expected call of PutResolverQueryLogConfigPolicy. +func (mr *MockRoute53ResolverAPIMockRecorder) PutResolverQueryLogConfigPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResolverQueryLogConfigPolicy", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutResolverQueryLogConfigPolicy), arg0) +} + +// PutResolverQueryLogConfigPolicyRequest mocks base method. +func (m *MockRoute53ResolverAPI) PutResolverQueryLogConfigPolicyRequest(arg0 *route53resolver.PutResolverQueryLogConfigPolicyInput) (*request.Request, *route53resolver.PutResolverQueryLogConfigPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutResolverQueryLogConfigPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.PutResolverQueryLogConfigPolicyOutput) + return ret0, ret1 +} + +// PutResolverQueryLogConfigPolicyRequest indicates an expected call of PutResolverQueryLogConfigPolicyRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) PutResolverQueryLogConfigPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResolverQueryLogConfigPolicyRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutResolverQueryLogConfigPolicyRequest), arg0) +} + +// PutResolverQueryLogConfigPolicyWithContext mocks base method. +func (m *MockRoute53ResolverAPI) PutResolverQueryLogConfigPolicyWithContext(arg0 aws.Context, arg1 *route53resolver.PutResolverQueryLogConfigPolicyInput, arg2 ...request.Option) (*route53resolver.PutResolverQueryLogConfigPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutResolverQueryLogConfigPolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.PutResolverQueryLogConfigPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutResolverQueryLogConfigPolicyWithContext indicates an expected call of PutResolverQueryLogConfigPolicyWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) PutResolverQueryLogConfigPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResolverQueryLogConfigPolicyWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutResolverQueryLogConfigPolicyWithContext), varargs...) +} + +// PutResolverRulePolicy mocks base method. +func (m *MockRoute53ResolverAPI) PutResolverRulePolicy(arg0 *route53resolver.PutResolverRulePolicyInput) (*route53resolver.PutResolverRulePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutResolverRulePolicy", arg0) + ret0, _ := ret[0].(*route53resolver.PutResolverRulePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutResolverRulePolicy indicates an expected call of PutResolverRulePolicy. +func (mr *MockRoute53ResolverAPIMockRecorder) PutResolverRulePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResolverRulePolicy", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutResolverRulePolicy), arg0) +} + +// PutResolverRulePolicyRequest mocks base method. +func (m *MockRoute53ResolverAPI) PutResolverRulePolicyRequest(arg0 *route53resolver.PutResolverRulePolicyInput) (*request.Request, *route53resolver.PutResolverRulePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutResolverRulePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.PutResolverRulePolicyOutput) + return ret0, ret1 +} + +// PutResolverRulePolicyRequest indicates an expected call of PutResolverRulePolicyRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) PutResolverRulePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResolverRulePolicyRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutResolverRulePolicyRequest), arg0) +} + +// PutResolverRulePolicyWithContext mocks base method. +func (m *MockRoute53ResolverAPI) PutResolverRulePolicyWithContext(arg0 aws.Context, arg1 *route53resolver.PutResolverRulePolicyInput, arg2 ...request.Option) (*route53resolver.PutResolverRulePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutResolverRulePolicyWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.PutResolverRulePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutResolverRulePolicyWithContext indicates an expected call of PutResolverRulePolicyWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) PutResolverRulePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResolverRulePolicyWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).PutResolverRulePolicyWithContext), varargs...) +} + +// TagResource mocks base method. +func (m *MockRoute53ResolverAPI) TagResource(arg0 *route53resolver.TagResourceInput) (*route53resolver.TagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResource", arg0) + ret0, _ := ret[0].(*route53resolver.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResource indicates an expected call of TagResource. +func (mr *MockRoute53ResolverAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).TagResource), arg0) +} + +// TagResourceRequest mocks base method. +func (m *MockRoute53ResolverAPI) TagResourceRequest(arg0 *route53resolver.TagResourceInput) (*request.Request, *route53resolver.TagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.TagResourceOutput) + return ret0, ret1 +} + +// TagResourceRequest indicates an expected call of TagResourceRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).TagResourceRequest), arg0) +} + +// TagResourceWithContext mocks base method. +func (m *MockRoute53ResolverAPI) TagResourceWithContext(arg0 aws.Context, arg1 *route53resolver.TagResourceInput, arg2 ...request.Option) (*route53resolver.TagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResourceWithContext indicates an expected call of TagResourceWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).TagResourceWithContext), varargs...) +} + +// UntagResource mocks base method. +func (m *MockRoute53ResolverAPI) UntagResource(arg0 *route53resolver.UntagResourceInput) (*route53resolver.UntagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResource", arg0) + ret0, _ := ret[0].(*route53resolver.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResource indicates an expected call of UntagResource. +func (mr *MockRoute53ResolverAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UntagResource), arg0) +} + +// UntagResourceRequest mocks base method. +func (m *MockRoute53ResolverAPI) UntagResourceRequest(arg0 *route53resolver.UntagResourceInput) (*request.Request, *route53resolver.UntagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UntagResourceOutput) + return ret0, ret1 +} + +// UntagResourceRequest indicates an expected call of UntagResourceRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UntagResourceRequest), arg0) +} + +// UntagResourceWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *route53resolver.UntagResourceInput, arg2 ...request.Option) (*route53resolver.UntagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResourceWithContext indicates an expected call of UntagResourceWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UntagResourceWithContext), varargs...) +} + +// UpdateFirewallConfig mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallConfig(arg0 *route53resolver.UpdateFirewallConfigInput) (*route53resolver.UpdateFirewallConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFirewallConfig", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateFirewallConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFirewallConfig indicates an expected call of UpdateFirewallConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallConfig), arg0) +} + +// UpdateFirewallConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallConfigRequest(arg0 *route53resolver.UpdateFirewallConfigInput) (*request.Request, *route53resolver.UpdateFirewallConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFirewallConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateFirewallConfigOutput) + return ret0, ret1 +} + +// UpdateFirewallConfigRequest indicates an expected call of UpdateFirewallConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallConfigRequest), arg0) +} + +// UpdateFirewallConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallConfigWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateFirewallConfigInput, arg2 ...request.Option) (*route53resolver.UpdateFirewallConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateFirewallConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateFirewallConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFirewallConfigWithContext indicates an expected call of UpdateFirewallConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallConfigWithContext), varargs...) +} + +// UpdateFirewallDomains mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallDomains(arg0 *route53resolver.UpdateFirewallDomainsInput) (*route53resolver.UpdateFirewallDomainsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFirewallDomains", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateFirewallDomainsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFirewallDomains indicates an expected call of UpdateFirewallDomains. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallDomains(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallDomains", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallDomains), arg0) +} + +// UpdateFirewallDomainsRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallDomainsRequest(arg0 *route53resolver.UpdateFirewallDomainsInput) (*request.Request, *route53resolver.UpdateFirewallDomainsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFirewallDomainsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateFirewallDomainsOutput) + return ret0, ret1 +} + +// UpdateFirewallDomainsRequest indicates an expected call of UpdateFirewallDomainsRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallDomainsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallDomainsRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallDomainsRequest), arg0) +} + +// UpdateFirewallDomainsWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallDomainsWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateFirewallDomainsInput, arg2 ...request.Option) (*route53resolver.UpdateFirewallDomainsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateFirewallDomainsWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateFirewallDomainsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFirewallDomainsWithContext indicates an expected call of UpdateFirewallDomainsWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallDomainsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallDomainsWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallDomainsWithContext), varargs...) +} + +// UpdateFirewallRule mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallRule(arg0 *route53resolver.UpdateFirewallRuleInput) (*route53resolver.UpdateFirewallRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFirewallRule", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateFirewallRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFirewallRule indicates an expected call of UpdateFirewallRule. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallRule), arg0) +} + +// UpdateFirewallRuleGroupAssociation mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallRuleGroupAssociation(arg0 *route53resolver.UpdateFirewallRuleGroupAssociationInput) (*route53resolver.UpdateFirewallRuleGroupAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFirewallRuleGroupAssociation", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateFirewallRuleGroupAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFirewallRuleGroupAssociation indicates an expected call of UpdateFirewallRuleGroupAssociation. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallRuleGroupAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallRuleGroupAssociation", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallRuleGroupAssociation), arg0) +} + +// UpdateFirewallRuleGroupAssociationRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallRuleGroupAssociationRequest(arg0 *route53resolver.UpdateFirewallRuleGroupAssociationInput) (*request.Request, *route53resolver.UpdateFirewallRuleGroupAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFirewallRuleGroupAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateFirewallRuleGroupAssociationOutput) + return ret0, ret1 +} + +// UpdateFirewallRuleGroupAssociationRequest indicates an expected call of UpdateFirewallRuleGroupAssociationRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallRuleGroupAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallRuleGroupAssociationRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallRuleGroupAssociationRequest), arg0) +} + +// UpdateFirewallRuleGroupAssociationWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallRuleGroupAssociationWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateFirewallRuleGroupAssociationInput, arg2 ...request.Option) (*route53resolver.UpdateFirewallRuleGroupAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateFirewallRuleGroupAssociationWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateFirewallRuleGroupAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFirewallRuleGroupAssociationWithContext indicates an expected call of UpdateFirewallRuleGroupAssociationWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallRuleGroupAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallRuleGroupAssociationWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallRuleGroupAssociationWithContext), varargs...) +} + +// UpdateFirewallRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallRuleRequest(arg0 *route53resolver.UpdateFirewallRuleInput) (*request.Request, *route53resolver.UpdateFirewallRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateFirewallRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateFirewallRuleOutput) + return ret0, ret1 +} + +// UpdateFirewallRuleRequest indicates an expected call of UpdateFirewallRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallRuleRequest), arg0) +} + +// UpdateFirewallRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateFirewallRuleWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateFirewallRuleInput, arg2 ...request.Option) (*route53resolver.UpdateFirewallRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateFirewallRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateFirewallRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateFirewallRuleWithContext indicates an expected call of UpdateFirewallRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateFirewallRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirewallRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateFirewallRuleWithContext), varargs...) +} + +// UpdateOutpostResolver mocks base method. +func (m *MockRoute53ResolverAPI) UpdateOutpostResolver(arg0 *route53resolver.UpdateOutpostResolverInput) (*route53resolver.UpdateOutpostResolverOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateOutpostResolver", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateOutpostResolverOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateOutpostResolver indicates an expected call of UpdateOutpostResolver. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateOutpostResolver(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOutpostResolver", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateOutpostResolver), arg0) +} + +// UpdateOutpostResolverRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateOutpostResolverRequest(arg0 *route53resolver.UpdateOutpostResolverInput) (*request.Request, *route53resolver.UpdateOutpostResolverOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateOutpostResolverRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateOutpostResolverOutput) + return ret0, ret1 +} + +// UpdateOutpostResolverRequest indicates an expected call of UpdateOutpostResolverRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateOutpostResolverRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOutpostResolverRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateOutpostResolverRequest), arg0) +} + +// UpdateOutpostResolverWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateOutpostResolverWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateOutpostResolverInput, arg2 ...request.Option) (*route53resolver.UpdateOutpostResolverOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateOutpostResolverWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateOutpostResolverOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateOutpostResolverWithContext indicates an expected call of UpdateOutpostResolverWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateOutpostResolverWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOutpostResolverWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateOutpostResolverWithContext), varargs...) +} + +// UpdateResolverConfig mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverConfig(arg0 *route53resolver.UpdateResolverConfigInput) (*route53resolver.UpdateResolverConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateResolverConfig", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateResolverConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateResolverConfig indicates an expected call of UpdateResolverConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverConfig), arg0) +} + +// UpdateResolverConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverConfigRequest(arg0 *route53resolver.UpdateResolverConfigInput) (*request.Request, *route53resolver.UpdateResolverConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateResolverConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateResolverConfigOutput) + return ret0, ret1 +} + +// UpdateResolverConfigRequest indicates an expected call of UpdateResolverConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverConfigRequest), arg0) +} + +// UpdateResolverConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverConfigWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateResolverConfigInput, arg2 ...request.Option) (*route53resolver.UpdateResolverConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateResolverConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateResolverConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateResolverConfigWithContext indicates an expected call of UpdateResolverConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverConfigWithContext), varargs...) +} + +// UpdateResolverDnssecConfig mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverDnssecConfig(arg0 *route53resolver.UpdateResolverDnssecConfigInput) (*route53resolver.UpdateResolverDnssecConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateResolverDnssecConfig", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateResolverDnssecConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateResolverDnssecConfig indicates an expected call of UpdateResolverDnssecConfig. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverDnssecConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverDnssecConfig", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverDnssecConfig), arg0) +} + +// UpdateResolverDnssecConfigRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverDnssecConfigRequest(arg0 *route53resolver.UpdateResolverDnssecConfigInput) (*request.Request, *route53resolver.UpdateResolverDnssecConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateResolverDnssecConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateResolverDnssecConfigOutput) + return ret0, ret1 +} + +// UpdateResolverDnssecConfigRequest indicates an expected call of UpdateResolverDnssecConfigRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverDnssecConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverDnssecConfigRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverDnssecConfigRequest), arg0) +} + +// UpdateResolverDnssecConfigWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverDnssecConfigWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateResolverDnssecConfigInput, arg2 ...request.Option) (*route53resolver.UpdateResolverDnssecConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateResolverDnssecConfigWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateResolverDnssecConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateResolverDnssecConfigWithContext indicates an expected call of UpdateResolverDnssecConfigWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverDnssecConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverDnssecConfigWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverDnssecConfigWithContext), varargs...) +} + +// UpdateResolverEndpoint mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverEndpoint(arg0 *route53resolver.UpdateResolverEndpointInput) (*route53resolver.UpdateResolverEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateResolverEndpoint", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateResolverEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateResolverEndpoint indicates an expected call of UpdateResolverEndpoint. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverEndpoint", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverEndpoint), arg0) +} + +// UpdateResolverEndpointRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverEndpointRequest(arg0 *route53resolver.UpdateResolverEndpointInput) (*request.Request, *route53resolver.UpdateResolverEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateResolverEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateResolverEndpointOutput) + return ret0, ret1 +} + +// UpdateResolverEndpointRequest indicates an expected call of UpdateResolverEndpointRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverEndpointRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverEndpointRequest), arg0) +} + +// UpdateResolverEndpointWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverEndpointWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateResolverEndpointInput, arg2 ...request.Option) (*route53resolver.UpdateResolverEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateResolverEndpointWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateResolverEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateResolverEndpointWithContext indicates an expected call of UpdateResolverEndpointWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverEndpointWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverEndpointWithContext), varargs...) +} + +// UpdateResolverRule mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverRule(arg0 *route53resolver.UpdateResolverRuleInput) (*route53resolver.UpdateResolverRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateResolverRule", arg0) + ret0, _ := ret[0].(*route53resolver.UpdateResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateResolverRule indicates an expected call of UpdateResolverRule. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverRule", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverRule), arg0) +} + +// UpdateResolverRuleRequest mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverRuleRequest(arg0 *route53resolver.UpdateResolverRuleInput) (*request.Request, *route53resolver.UpdateResolverRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateResolverRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*route53resolver.UpdateResolverRuleOutput) + return ret0, ret1 +} + +// UpdateResolverRuleRequest indicates an expected call of UpdateResolverRuleRequest. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverRuleRequest", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverRuleRequest), arg0) +} + +// UpdateResolverRuleWithContext mocks base method. +func (m *MockRoute53ResolverAPI) UpdateResolverRuleWithContext(arg0 aws.Context, arg1 *route53resolver.UpdateResolverRuleInput, arg2 ...request.Option) (*route53resolver.UpdateResolverRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateResolverRuleWithContext", varargs...) + ret0, _ := ret[0].(*route53resolver.UpdateResolverRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateResolverRuleWithContext indicates an expected call of UpdateResolverRuleWithContext. +func (mr *MockRoute53ResolverAPIMockRecorder) UpdateResolverRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResolverRuleWithContext", reflect.TypeOf((*MockRoute53ResolverAPI)(nil).UpdateResolverRuleWithContext), varargs...) +} diff --git a/resources/route53_mock_test.go b/resources/route53_mock_test.go index ae38e54d..2023ea32 100644 --- a/resources/route53_mock_test.go +++ b/resources/route53_mock_test.go @@ -1,4 +1,5 @@ //go:generate ../mocks/generate_mocks.sh route53 route53iface +//go:generate ../mocks/generate_mocks.sh route53resolver route53resolveriface package resources // Note: empty on purpose, this file exist purely to generate mocks for the Route53 service From 9faec90a234336aa284e5ff1b48e4dbeac504089 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 11 Sep 2024 13:30:00 -0600 Subject: [PATCH 4/5] test(route53-resolver-rule): increase test coverage --- resources/route53-resolver-rule.go | 93 +++---- resources/route53-resolver-rule_mock_test.go | 268 +++++++++++++++++++ 2 files changed, 315 insertions(+), 46 deletions(-) create mode 100644 resources/route53-resolver-rule_mock_test.go diff --git a/resources/route53-resolver-rule.go b/resources/route53-resolver-rule.go index b9e21771..2a854546 100644 --- a/resources/route53-resolver-rule.go +++ b/resources/route53-resolver-rule.go @@ -8,6 +8,7 @@ import ( "github.com/gotidy/ptr" "github.com/aws/aws-sdk-go/service/route53resolver" + "github.com/aws/aws-sdk-go/service/route53resolver/route53resolveriface" "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" @@ -26,14 +27,21 @@ func init() { }) } -type Route53ResolverRuleLister struct{} +type Route53ResolverRuleLister struct { + mockSvc route53resolveriface.Route53ResolverAPI +} // List returns a list of all Route53 ResolverRules before filtering to be nuked func (l *Route53ResolverRuleLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) var resources []resource.Resource - svc := route53resolver.New(opts.Session) + var svc route53resolveriface.Route53ResolverAPI + if l.mockSvc != nil { + svc = l.mockSvc + } else { + svc = route53resolver.New(opts.Session) + } vpcAssociations, vpcErr := resolverRulesToVpcIDs(svc) if vpcErr != nil { @@ -43,7 +51,6 @@ func (l *Route53ResolverRuleLister) List(_ context.Context, o interface{}) ([]re params := &route53resolver.ListResolverRulesInput{} for { resp, err := svc.ListResolverRules(params) - if err != nil { return nil, err } @@ -68,45 +75,9 @@ func (l *Route53ResolverRuleLister) List(_ context.Context, o interface{}) ([]re return resources, nil } -// resolverRulesToVpcIDs - Associate all the vpcIDs to their resolver rule ID to be disassociated before deleting the rule. -func resolverRulesToVpcIDs(svc *route53resolver.Route53Resolver) (map[string][]*string, error) { - vpcAssociations := map[string][]*string{} - - params := &route53resolver.ListResolverRuleAssociationsInput{} - - for { - resp, err := svc.ListResolverRuleAssociations(params) - - if err != nil { - return nil, err - } - - for _, ruleAssociation := range resp.ResolverRuleAssociations { - vpcID := ruleAssociation.VPCId - if vpcID != nil { - resolverRuleID := *ruleAssociation.ResolverRuleId - - if _, ok := vpcAssociations[resolverRuleID]; !ok { - vpcAssociations[resolverRuleID] = []*string{vpcID} - } else { - vpcAssociations[resolverRuleID] = append(vpcAssociations[resolverRuleID], vpcID) - } - } - } - - if resp.NextToken == nil { - break - } - - params.NextToken = resp.NextToken - } - - return vpcAssociations, nil -} - // Route53ResolverRule is the resource type type Route53ResolverRule struct { - svc *route53resolver.Route53Resolver + svc route53resolveriface.Route53ResolverAPI vpcIds []*string ID *string Name *string @@ -119,11 +90,6 @@ func (r *Route53ResolverRule) Filter() error { return fmt.Errorf("cannot delete system defined rules") } - // TODO: is this needed if the system defined is already filtered? - if r.DomainName != nil && ptr.ToString(r.DomainName) == "." { - return fmt.Errorf(`filtering DomainName "."`) - } - return nil } @@ -134,7 +100,6 @@ func (r *Route53ResolverRule) Remove(_ context.Context) error { ResolverRuleId: r.ID, VPCId: vpcID, }) - if err != nil { return err } @@ -156,3 +121,39 @@ func (r *Route53ResolverRule) Properties() types.Properties { func (r *Route53ResolverRule) String() string { return fmt.Sprintf("%s (%s)", ptr.ToString(r.ID), ptr.ToString(r.Name)) } + +// resolverRulesToVpcIDs - Associate all the vpcIDs to their resolver rule ID to be disassociated before deleting the rule. +func resolverRulesToVpcIDs(svc route53resolveriface.Route53ResolverAPI) (map[string][]*string, error) { + vpcAssociations := map[string][]*string{} + + params := &route53resolver.ListResolverRuleAssociationsInput{} + + for { + resp, err := svc.ListResolverRuleAssociations(params) + + if err != nil { + return nil, err + } + + for _, ruleAssociation := range resp.ResolverRuleAssociations { + vpcID := ruleAssociation.VPCId + if vpcID != nil { + resolverRuleID := *ruleAssociation.ResolverRuleId + + if _, ok := vpcAssociations[resolverRuleID]; !ok { + vpcAssociations[resolverRuleID] = []*string{vpcID} + } else { + vpcAssociations[resolverRuleID] = append(vpcAssociations[resolverRuleID], vpcID) + } + } + } + + if resp.NextToken == nil { + break + } + + params.NextToken = resp.NextToken + } + + return vpcAssociations, nil +} diff --git a/resources/route53-resolver-rule_mock_test.go b/resources/route53-resolver-rule_mock_test.go new file mode 100644 index 00000000..2954c72d --- /dev/null +++ b/resources/route53-resolver-rule_mock_test.go @@ -0,0 +1,268 @@ +package resources + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go/aws" + "testing" + + "github.com/golang/mock/gomock" + "github.com/gotidy/ptr" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/route53resolver" + + "github.com/ekristen/libnuke/pkg/resource" + + "github.com/ekristen/aws-nuke/v3/mocks/mock_route53resolveriface" + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +func Test_Mock_Route53ResolverRule_List(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockRoute53Resolver := mock_route53resolveriface.NewMockRoute53ResolverAPI(ctrl) + + mockRoute53Resolver.EXPECT().ListResolverRules(gomock.Any()).Return(&route53resolver.ListResolverRulesOutput{ + ResolverRules: []*route53resolver.ResolverRule{ + { + Id: ptr.String("rslvr-rr-1"), + Name: ptr.String("rule1"), + DomainName: ptr.String("example.com"), + }, + { + Id: ptr.String("rslvr-rr-2"), + Name: ptr.String("rule2"), + DomainName: ptr.String("example.org"), + }, + { + Id: ptr.String("rslvr-autodefined-rr-3"), + Name: ptr.String("Internet Resolver"), + DomainName: ptr.String("."), + }, + }, + }, nil) + + mockRoute53Resolver.EXPECT().ListResolverRuleAssociations(gomock.Any()).Return(&route53resolver.ListResolverRuleAssociationsOutput{ + ResolverRuleAssociations: []*route53resolver.ResolverRuleAssociation{ + { + ResolverRuleId: ptr.String("rslvr-rr-1"), + VPCId: ptr.String("vpc-1"), + }, + { + ResolverRuleId: ptr.String("rslvr-rr-2"), + VPCId: ptr.String("vpc-2"), + }, + { + ResolverRuleId: ptr.String("rslvr-autodefined-rr-3"), + VPCId: ptr.String("vpc-3"), + }, + }, + }, nil) + + lister := &Route53ResolverRuleLister{ + mockSvc: mockRoute53Resolver, + } + + resources, err := lister.List(context.TODO(), &nuke.ListerOpts{ + Region: &nuke.Region{ + Name: "us-east-2", + }, + Session: session.Must(session.NewSession()), + }) + a.Nil(err) + a.Len(resources, 3) + + expectedResources := []resource.Resource{ + &Route53ResolverRule{ + svc: mockRoute53Resolver, + vpcIds: []*string{ptr.String("vpc-1")}, + ID: ptr.String("rslvr-rr-1"), + Name: ptr.String("rule1"), + DomainName: ptr.String("example.com"), + }, + &Route53ResolverRule{ + svc: mockRoute53Resolver, + vpcIds: []*string{ptr.String("vpc-2")}, + ID: ptr.String("rslvr-rr-2"), + Name: ptr.String("rule2"), + DomainName: ptr.String("example.org"), + }, + &Route53ResolverRule{ + svc: mockRoute53Resolver, + vpcIds: []*string{ptr.String("vpc-3")}, + ID: ptr.String("rslvr-autodefined-rr-3"), + Name: ptr.String("Internet Resolver"), + DomainName: ptr.String("."), + }, + } + + a.Equal(expectedResources, resources) +} + +func Test_Mock_Route53ResolverRule_Filter(t *testing.T) { + a := assert.New(t) + + cases := []struct { + Name string + ID string + DomainName string + Filtered bool + }{ + { + ID: "rslvr-rr-1", + DomainName: "example.com", + Filtered: false, + }, + { + ID: "rslvr-autodefined-rr-1", + DomainName: ".", + Filtered: true, + }, + } + + for _, c := range cases { + name := c.ID + if c.Filtered { + name = fmt.Sprintf("filtered/%s", name) + } else { + name = fmt.Sprintf("not-filtered/%s", name) + } + + t.Run(name, func(t *testing.T) { + rule := &Route53ResolverRule{ + ID: ptr.String(c.ID), + DomainName: ptr.String(c.DomainName), + } + + err := rule.Filter() + if c.Filtered { + a.NotNil(err) + } else { + a.Nil(err) + } + }) + } +} + +func Test_Mock_Route53ResolverRule_Remove(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockRoute53Resolver := mock_route53resolveriface.NewMockRoute53ResolverAPI(ctrl) + + mockRoute53Resolver.EXPECT(). + DisassociateResolverRule(gomock.Any()). + Return(&route53resolver.DisassociateResolverRuleOutput{}, nil).Times(2) + + mockRoute53Resolver.EXPECT(). + DeleteResolverRule(gomock.Any()). + Return(&route53resolver.DeleteResolverRuleOutput{}, nil) + + rule := &Route53ResolverRule{ + svc: mockRoute53Resolver, + vpcIds: []*string{ptr.String("vpc-1"), ptr.String("vpc-2")}, + ID: ptr.String("rslvr-rr-1"), + Name: ptr.String("rule1"), + DomainName: ptr.String("example.com"), + } + + err := rule.Remove(context.TODO()) + a.Nil(err) +} + +func Test_Mock_Route53ResolverRule_Properties(t *testing.T) { + a := assert.New(t) + + rule := &Route53ResolverRule{ + ID: ptr.String("rslvr-rr-1"), + Name: ptr.String("rule1"), + DomainName: ptr.String("example.com"), + } + + properties := rule.Properties() + a.Equal("rslvr-rr-1", properties.Get("ID")) + a.Equal("rule1", properties.Get("Name")) + a.Equal("example.com", properties.Get("DomainName")) + + a.Equal("rslvr-rr-1 (rule1)", rule.String()) + + rule.Name = nil + a.Equal("rslvr-rr-1 ()", rule.String()) +} + +func Test_resolverRulesToVpcIDs(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockRoute53Resolver := mock_route53resolveriface.NewMockRoute53ResolverAPI(ctrl) + + // Test case: Error from ListResolverRuleAssociations + mockRoute53Resolver.EXPECT(). + ListResolverRuleAssociations(gomock.Any()). + Return(nil, aws.ErrMissingEndpoint) + + vpcAssociations, err := resolverRulesToVpcIDs(mockRoute53Resolver) + a.Nil(vpcAssociations) + a.NotNil(err) + a.EqualError(err, aws.ErrMissingEndpoint.Error()) + + // Test case: Paginated results with NextToken + mockRoute53Resolver.EXPECT(). + ListResolverRuleAssociations(&route53resolver.ListResolverRuleAssociationsInput{}). + Return(&route53resolver.ListResolverRuleAssociationsOutput{ + ResolverRuleAssociations: []*route53resolver.ResolverRuleAssociation{ + { + ResolverRuleId: aws.String("rslvr-rr-1"), + VPCId: aws.String("vpc-1"), + }, + }, + NextToken: aws.String("token1"), + }, nil) + + mockRoute53Resolver.EXPECT(). + ListResolverRuleAssociations(&route53resolver.ListResolverRuleAssociationsInput{ + NextToken: aws.String("token1"), + }).Return(&route53resolver.ListResolverRuleAssociationsOutput{ + ResolverRuleAssociations: []*route53resolver.ResolverRuleAssociation{ + { + ResolverRuleId: aws.String("rslvr-rr-2"), + VPCId: aws.String("vpc-2"), + }, + }, + }, nil) + + vpcAssociations, err = resolverRulesToVpcIDs(mockRoute53Resolver) + a.Nil(err) + a.NotNil(vpcAssociations) + a.Len(vpcAssociations, 2) + a.Equal([]*string{aws.String("vpc-1")}, vpcAssociations["rslvr-rr-1"]) + a.Equal([]*string{aws.String("vpc-2")}, vpcAssociations["rslvr-rr-2"]) + + // Test case: Multiple VPC associations for a single resolver rule + mockRoute53Resolver.EXPECT(). + ListResolverRuleAssociations(&route53resolver.ListResolverRuleAssociationsInput{}). + Return(&route53resolver.ListResolverRuleAssociationsOutput{ + ResolverRuleAssociations: []*route53resolver.ResolverRuleAssociation{ + { + ResolverRuleId: aws.String("rslvr-rr-3"), + VPCId: aws.String("vpc-3"), + }, + { + ResolverRuleId: aws.String("rslvr-rr-3"), + VPCId: aws.String("vpc-4"), + }, + }, + }, nil) + + vpcAssociations, err = resolverRulesToVpcIDs(mockRoute53Resolver) + a.Nil(err) + a.NotNil(vpcAssociations) + a.Len(vpcAssociations, 1) + a.Equal([]*string{aws.String("vpc-3"), aws.String("vpc-4")}, vpcAssociations["rslvr-rr-3"]) +} From 8af2e1e9adbaf2e65c3c03906a9f0a6363ae6873 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Wed, 11 Sep 2024 13:36:42 -0600 Subject: [PATCH 5/5] chore: fix lint violation --- resources/route53-resolver-rule_mock_test.go | 28 ++++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/resources/route53-resolver-rule_mock_test.go b/resources/route53-resolver-rule_mock_test.go index 2954c72d..6c5e1212 100644 --- a/resources/route53-resolver-rule_mock_test.go +++ b/resources/route53-resolver-rule_mock_test.go @@ -3,13 +3,13 @@ package resources import ( "context" "fmt" - "github.com/aws/aws-sdk-go/aws" "testing" "github.com/golang/mock/gomock" "github.com/gotidy/ptr" "github.com/stretchr/testify/assert" + "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/route53resolver" @@ -218,21 +218,21 @@ func Test_resolverRulesToVpcIDs(t *testing.T) { Return(&route53resolver.ListResolverRuleAssociationsOutput{ ResolverRuleAssociations: []*route53resolver.ResolverRuleAssociation{ { - ResolverRuleId: aws.String("rslvr-rr-1"), - VPCId: aws.String("vpc-1"), + ResolverRuleId: ptr.String("rslvr-rr-1"), + VPCId: ptr.String("vpc-1"), }, }, - NextToken: aws.String("token1"), + NextToken: ptr.String("token1"), }, nil) mockRoute53Resolver.EXPECT(). ListResolverRuleAssociations(&route53resolver.ListResolverRuleAssociationsInput{ - NextToken: aws.String("token1"), + NextToken: ptr.String("token1"), }).Return(&route53resolver.ListResolverRuleAssociationsOutput{ ResolverRuleAssociations: []*route53resolver.ResolverRuleAssociation{ { - ResolverRuleId: aws.String("rslvr-rr-2"), - VPCId: aws.String("vpc-2"), + ResolverRuleId: ptr.String("rslvr-rr-2"), + VPCId: ptr.String("vpc-2"), }, }, }, nil) @@ -241,8 +241,8 @@ func Test_resolverRulesToVpcIDs(t *testing.T) { a.Nil(err) a.NotNil(vpcAssociations) a.Len(vpcAssociations, 2) - a.Equal([]*string{aws.String("vpc-1")}, vpcAssociations["rslvr-rr-1"]) - a.Equal([]*string{aws.String("vpc-2")}, vpcAssociations["rslvr-rr-2"]) + a.Equal([]*string{ptr.String("vpc-1")}, vpcAssociations["rslvr-rr-1"]) + a.Equal([]*string{ptr.String("vpc-2")}, vpcAssociations["rslvr-rr-2"]) // Test case: Multiple VPC associations for a single resolver rule mockRoute53Resolver.EXPECT(). @@ -250,12 +250,12 @@ func Test_resolverRulesToVpcIDs(t *testing.T) { Return(&route53resolver.ListResolverRuleAssociationsOutput{ ResolverRuleAssociations: []*route53resolver.ResolverRuleAssociation{ { - ResolverRuleId: aws.String("rslvr-rr-3"), - VPCId: aws.String("vpc-3"), + ResolverRuleId: ptr.String("rslvr-rr-3"), + VPCId: ptr.String("vpc-3"), }, { - ResolverRuleId: aws.String("rslvr-rr-3"), - VPCId: aws.String("vpc-4"), + ResolverRuleId: ptr.String("rslvr-rr-3"), + VPCId: ptr.String("vpc-4"), }, }, }, nil) @@ -264,5 +264,5 @@ func Test_resolverRulesToVpcIDs(t *testing.T) { a.Nil(err) a.NotNil(vpcAssociations) a.Len(vpcAssociations, 1) - a.Equal([]*string{aws.String("vpc-3"), aws.String("vpc-4")}, vpcAssociations["rslvr-rr-3"]) + a.Equal([]*string{ptr.String("vpc-3"), ptr.String("vpc-4")}, vpcAssociations["rslvr-rr-3"]) }