// Code generated by MockGen. DO NOT EDIT.
// Source: /home/runner/go/pkg/mod/github.com/aws/aws-sdk-go@v1.55.5/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...)
}
