github.com/almamedia/fargate@v0.2.4-0.20220704071213-7b5b3d27c5eb/route53/mock/sdk/route53iface.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ../vendor/github.com/aws/aws-sdk-go/service/route53/route53iface/interface.go

// Package sdk is a generated GoMock package.
package sdk

import (
	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	route53 "github.com/aws/aws-sdk-go/service/route53"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockRoute53API is a mock of Route53API interface
type MockRoute53API struct {
	ctrl     *gomock.Controller
	recorder *MockRoute53APIMockRecorder
}

// MockRoute53APIMockRecorder is the mock recorder for MockRoute53API
type MockRoute53APIMockRecorder struct {
	mock *MockRoute53API
}

// NewMockRoute53API creates a new mock instance
func NewMockRoute53API(ctrl *gomock.Controller) *MockRoute53API {
	mock := &MockRoute53API{ctrl: ctrl}
	mock.recorder = &MockRoute53APIMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockRoute53API) EXPECT() *MockRoute53APIMockRecorder {
	return m.recorder
}

// AssociateVPCWithHostedZone mocks base method
func (m *MockRoute53API) AssociateVPCWithHostedZone(arg0 *route53.AssociateVPCWithHostedZoneInput) (*route53.AssociateVPCWithHostedZoneOutput, error) {
	ret := m.ctrl.Call(m, "AssociateVPCWithHostedZone", arg0)
	ret0, _ := ret[0].(*route53.AssociateVPCWithHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateVPCWithHostedZone indicates an expected call of AssociateVPCWithHostedZone
func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZone(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZone", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZone), arg0)
}

// AssociateVPCWithHostedZoneWithContext mocks base method
func (m *MockRoute53API) AssociateVPCWithHostedZoneWithContext(arg0 aws.Context, arg1 *route53.AssociateVPCWithHostedZoneInput, arg2 ...request.Option) (*route53.AssociateVPCWithHostedZoneOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateVPCWithHostedZoneWithContext", varargs...)
	ret0, _ := ret[0].(*route53.AssociateVPCWithHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateVPCWithHostedZoneWithContext indicates an expected call of AssociateVPCWithHostedZoneWithContext
func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZoneWithContext), varargs...)
}

// AssociateVPCWithHostedZoneRequest mocks base method
func (m *MockRoute53API) AssociateVPCWithHostedZoneRequest(arg0 *route53.AssociateVPCWithHostedZoneInput) (*request.Request, *route53.AssociateVPCWithHostedZoneOutput) {
	ret := m.ctrl.Call(m, "AssociateVPCWithHostedZoneRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.AssociateVPCWithHostedZoneOutput)
	return ret0, ret1
}

// AssociateVPCWithHostedZoneRequest indicates an expected call of AssociateVPCWithHostedZoneRequest
func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZoneRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZoneRequest), arg0)
}

// ChangeResourceRecordSets mocks base method
func (m *MockRoute53API) ChangeResourceRecordSets(arg0 *route53.ChangeResourceRecordSetsInput) (*route53.ChangeResourceRecordSetsOutput, error) {
	ret := m.ctrl.Call(m, "ChangeResourceRecordSets", arg0)
	ret0, _ := ret[0].(*route53.ChangeResourceRecordSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeResourceRecordSets indicates an expected call of ChangeResourceRecordSets
func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSets(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSets", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSets), arg0)
}

// ChangeResourceRecordSetsWithContext mocks base method
func (m *MockRoute53API) ChangeResourceRecordSetsWithContext(arg0 aws.Context, arg1 *route53.ChangeResourceRecordSetsInput, arg2 ...request.Option) (*route53.ChangeResourceRecordSetsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeResourceRecordSetsWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ChangeResourceRecordSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeResourceRecordSetsWithContext indicates an expected call of ChangeResourceRecordSetsWithContext
func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSetsWithContext), varargs...)
}

// ChangeResourceRecordSetsRequest mocks base method
func (m *MockRoute53API) ChangeResourceRecordSetsRequest(arg0 *route53.ChangeResourceRecordSetsInput) (*request.Request, *route53.ChangeResourceRecordSetsOutput) {
	ret := m.ctrl.Call(m, "ChangeResourceRecordSetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ChangeResourceRecordSetsOutput)
	return ret0, ret1
}

// ChangeResourceRecordSetsRequest indicates an expected call of ChangeResourceRecordSetsRequest
func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSetsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSetsRequest), arg0)
}

// ChangeTagsForResource mocks base method
func (m *MockRoute53API) ChangeTagsForResource(arg0 *route53.ChangeTagsForResourceInput) (*route53.ChangeTagsForResourceOutput, error) {
	ret := m.ctrl.Call(m, "ChangeTagsForResource", arg0)
	ret0, _ := ret[0].(*route53.ChangeTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeTagsForResource indicates an expected call of ChangeTagsForResource
func (mr *MockRoute53APIMockRecorder) ChangeTagsForResource(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResource", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResource), arg0)
}

// ChangeTagsForResourceWithContext mocks base method
func (m *MockRoute53API) ChangeTagsForResourceWithContext(arg0 aws.Context, arg1 *route53.ChangeTagsForResourceInput, arg2 ...request.Option) (*route53.ChangeTagsForResourceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeTagsForResourceWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ChangeTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeTagsForResourceWithContext indicates an expected call of ChangeTagsForResourceWithContext
func (mr *MockRoute53APIMockRecorder) ChangeTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResourceWithContext", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResourceWithContext), varargs...)
}

// ChangeTagsForResourceRequest mocks base method
func (m *MockRoute53API) ChangeTagsForResourceRequest(arg0 *route53.ChangeTagsForResourceInput) (*request.Request, *route53.ChangeTagsForResourceOutput) {
	ret := m.ctrl.Call(m, "ChangeTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ChangeTagsForResourceOutput)
	return ret0, ret1
}

// ChangeTagsForResourceRequest indicates an expected call of ChangeTagsForResourceRequest
func (mr *MockRoute53APIMockRecorder) ChangeTagsForResourceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResourceRequest", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResourceRequest), arg0)
}

// CreateHealthCheck mocks base method
func (m *MockRoute53API) CreateHealthCheck(arg0 *route53.CreateHealthCheckInput) (*route53.CreateHealthCheckOutput, error) {
	ret := m.ctrl.Call(m, "CreateHealthCheck", arg0)
	ret0, _ := ret[0].(*route53.CreateHealthCheckOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateHealthCheck indicates an expected call of CreateHealthCheck
func (mr *MockRoute53APIMockRecorder) CreateHealthCheck(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheck), arg0)
}

// CreateHealthCheckWithContext mocks base method
func (m *MockRoute53API) CreateHealthCheckWithContext(arg0 aws.Context, arg1 *route53.CreateHealthCheckInput, arg2 ...request.Option) (*route53.CreateHealthCheckOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateHealthCheckWithContext", varargs...)
	ret0, _ := ret[0].(*route53.CreateHealthCheckOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateHealthCheckWithContext indicates an expected call of CreateHealthCheckWithContext
func (mr *MockRoute53APIMockRecorder) CreateHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheckWithContext), varargs...)
}

// CreateHealthCheckRequest mocks base method
func (m *MockRoute53API) CreateHealthCheckRequest(arg0 *route53.CreateHealthCheckInput) (*request.Request, *route53.CreateHealthCheckOutput) {
	ret := m.ctrl.Call(m, "CreateHealthCheckRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.CreateHealthCheckOutput)
	return ret0, ret1
}

// CreateHealthCheckRequest indicates an expected call of CreateHealthCheckRequest
func (mr *MockRoute53APIMockRecorder) CreateHealthCheckRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheckRequest), arg0)
}

// CreateHostedZone mocks base method
func (m *MockRoute53API) CreateHostedZone(arg0 *route53.CreateHostedZoneInput) (*route53.CreateHostedZoneOutput, error) {
	ret := m.ctrl.Call(m, "CreateHostedZone", arg0)
	ret0, _ := ret[0].(*route53.CreateHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateHostedZone indicates an expected call of CreateHostedZone
func (mr *MockRoute53APIMockRecorder) CreateHostedZone(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZone", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZone), arg0)
}

// CreateHostedZoneWithContext mocks base method
func (m *MockRoute53API) CreateHostedZoneWithContext(arg0 aws.Context, arg1 *route53.CreateHostedZoneInput, arg2 ...request.Option) (*route53.CreateHostedZoneOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateHostedZoneWithContext", varargs...)
	ret0, _ := ret[0].(*route53.CreateHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateHostedZoneWithContext indicates an expected call of CreateHostedZoneWithContext
func (mr *MockRoute53APIMockRecorder) CreateHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZoneWithContext), varargs...)
}

// CreateHostedZoneRequest mocks base method
func (m *MockRoute53API) CreateHostedZoneRequest(arg0 *route53.CreateHostedZoneInput) (*request.Request, *route53.CreateHostedZoneOutput) {
	ret := m.ctrl.Call(m, "CreateHostedZoneRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.CreateHostedZoneOutput)
	return ret0, ret1
}

// CreateHostedZoneRequest indicates an expected call of CreateHostedZoneRequest
func (mr *MockRoute53APIMockRecorder) CreateHostedZoneRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZoneRequest), arg0)
}

// CreateQueryLoggingConfig mocks base method
func (m *MockRoute53API) CreateQueryLoggingConfig(arg0 *route53.CreateQueryLoggingConfigInput) (*route53.CreateQueryLoggingConfigOutput, error) {
	ret := m.ctrl.Call(m, "CreateQueryLoggingConfig", arg0)
	ret0, _ := ret[0].(*route53.CreateQueryLoggingConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateQueryLoggingConfig indicates an expected call of CreateQueryLoggingConfig
func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfig(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfig), arg0)
}

// CreateQueryLoggingConfigWithContext mocks base method
func (m *MockRoute53API) CreateQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.CreateQueryLoggingConfigInput, arg2 ...request.Option) (*route53.CreateQueryLoggingConfigOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateQueryLoggingConfigWithContext", varargs...)
	ret0, _ := ret[0].(*route53.CreateQueryLoggingConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateQueryLoggingConfigWithContext indicates an expected call of CreateQueryLoggingConfigWithContext
func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfigWithContext), varargs...)
}

// CreateQueryLoggingConfigRequest mocks base method
func (m *MockRoute53API) CreateQueryLoggingConfigRequest(arg0 *route53.CreateQueryLoggingConfigInput) (*request.Request, *route53.CreateQueryLoggingConfigOutput) {
	ret := m.ctrl.Call(m, "CreateQueryLoggingConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.CreateQueryLoggingConfigOutput)
	return ret0, ret1
}

// CreateQueryLoggingConfigRequest indicates an expected call of CreateQueryLoggingConfigRequest
func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfigRequest), arg0)
}

// CreateReusableDelegationSet mocks base method
func (m *MockRoute53API) CreateReusableDelegationSet(arg0 *route53.CreateReusableDelegationSetInput) (*route53.CreateReusableDelegationSetOutput, error) {
	ret := m.ctrl.Call(m, "CreateReusableDelegationSet", arg0)
	ret0, _ := ret[0].(*route53.CreateReusableDelegationSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReusableDelegationSet indicates an expected call of CreateReusableDelegationSet
func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSet(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSet), arg0)
}

// CreateReusableDelegationSetWithContext mocks base method
func (m *MockRoute53API) CreateReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.CreateReusableDelegationSetInput, arg2 ...request.Option) (*route53.CreateReusableDelegationSetOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateReusableDelegationSetWithContext", varargs...)
	ret0, _ := ret[0].(*route53.CreateReusableDelegationSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReusableDelegationSetWithContext indicates an expected call of CreateReusableDelegationSetWithContext
func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSetWithContext), varargs...)
}

// CreateReusableDelegationSetRequest mocks base method
func (m *MockRoute53API) CreateReusableDelegationSetRequest(arg0 *route53.CreateReusableDelegationSetInput) (*request.Request, *route53.CreateReusableDelegationSetOutput) {
	ret := m.ctrl.Call(m, "CreateReusableDelegationSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.CreateReusableDelegationSetOutput)
	return ret0, ret1
}

// CreateReusableDelegationSetRequest indicates an expected call of CreateReusableDelegationSetRequest
func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSetRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSetRequest), arg0)
}

// CreateTrafficPolicy mocks base method
func (m *MockRoute53API) CreateTrafficPolicy(arg0 *route53.CreateTrafficPolicyInput) (*route53.CreateTrafficPolicyOutput, error) {
	ret := m.ctrl.Call(m, "CreateTrafficPolicy", arg0)
	ret0, _ := ret[0].(*route53.CreateTrafficPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficPolicy indicates an expected call of CreateTrafficPolicy
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicy(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicy), arg0)
}

// CreateTrafficPolicyWithContext mocks base method
func (m *MockRoute53API) CreateTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrafficPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*route53.CreateTrafficPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficPolicyWithContext indicates an expected call of CreateTrafficPolicyWithContext
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyWithContext), varargs...)
}

// CreateTrafficPolicyRequest mocks base method
func (m *MockRoute53API) CreateTrafficPolicyRequest(arg0 *route53.CreateTrafficPolicyInput) (*request.Request, *route53.CreateTrafficPolicyOutput) {
	ret := m.ctrl.Call(m, "CreateTrafficPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.CreateTrafficPolicyOutput)
	return ret0, ret1
}

// CreateTrafficPolicyRequest indicates an expected call of CreateTrafficPolicyRequest
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyRequest), arg0)
}

// CreateTrafficPolicyInstance mocks base method
func (m *MockRoute53API) CreateTrafficPolicyInstance(arg0 *route53.CreateTrafficPolicyInstanceInput) (*route53.CreateTrafficPolicyInstanceOutput, error) {
	ret := m.ctrl.Call(m, "CreateTrafficPolicyInstance", arg0)
	ret0, _ := ret[0].(*route53.CreateTrafficPolicyInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficPolicyInstance indicates an expected call of CreateTrafficPolicyInstance
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstance(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstance), arg0)
}

// CreateTrafficPolicyInstanceWithContext mocks base method
func (m *MockRoute53API) CreateTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyInstanceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrafficPolicyInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*route53.CreateTrafficPolicyInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficPolicyInstanceWithContext indicates an expected call of CreateTrafficPolicyInstanceWithContext
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstanceWithContext), varargs...)
}

// CreateTrafficPolicyInstanceRequest mocks base method
func (m *MockRoute53API) CreateTrafficPolicyInstanceRequest(arg0 *route53.CreateTrafficPolicyInstanceInput) (*request.Request, *route53.CreateTrafficPolicyInstanceOutput) {
	ret := m.ctrl.Call(m, "CreateTrafficPolicyInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.CreateTrafficPolicyInstanceOutput)
	return ret0, ret1
}

// CreateTrafficPolicyInstanceRequest indicates an expected call of CreateTrafficPolicyInstanceRequest
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstanceRequest), arg0)
}

// CreateTrafficPolicyVersion mocks base method
func (m *MockRoute53API) CreateTrafficPolicyVersion(arg0 *route53.CreateTrafficPolicyVersionInput) (*route53.CreateTrafficPolicyVersionOutput, error) {
	ret := m.ctrl.Call(m, "CreateTrafficPolicyVersion", arg0)
	ret0, _ := ret[0].(*route53.CreateTrafficPolicyVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficPolicyVersion indicates an expected call of CreateTrafficPolicyVersion
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersion(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersion", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersion), arg0)
}

// CreateTrafficPolicyVersionWithContext mocks base method
func (m *MockRoute53API) CreateTrafficPolicyVersionWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyVersionInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyVersionOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrafficPolicyVersionWithContext", varargs...)
	ret0, _ := ret[0].(*route53.CreateTrafficPolicyVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficPolicyVersionWithContext indicates an expected call of CreateTrafficPolicyVersionWithContext
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersionWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersionWithContext), varargs...)
}

// CreateTrafficPolicyVersionRequest mocks base method
func (m *MockRoute53API) CreateTrafficPolicyVersionRequest(arg0 *route53.CreateTrafficPolicyVersionInput) (*request.Request, *route53.CreateTrafficPolicyVersionOutput) {
	ret := m.ctrl.Call(m, "CreateTrafficPolicyVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.CreateTrafficPolicyVersionOutput)
	return ret0, ret1
}

// CreateTrafficPolicyVersionRequest indicates an expected call of CreateTrafficPolicyVersionRequest
func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersionRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersionRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersionRequest), arg0)
}

// CreateVPCAssociationAuthorization mocks base method
func (m *MockRoute53API) CreateVPCAssociationAuthorization(arg0 *route53.CreateVPCAssociationAuthorizationInput) (*route53.CreateVPCAssociationAuthorizationOutput, error) {
	ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorization", arg0)
	ret0, _ := ret[0].(*route53.CreateVPCAssociationAuthorizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVPCAssociationAuthorization indicates an expected call of CreateVPCAssociationAuthorization
func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorization(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorization", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorization), arg0)
}

// CreateVPCAssociationAuthorizationWithContext mocks base method
func (m *MockRoute53API) CreateVPCAssociationAuthorizationWithContext(arg0 aws.Context, arg1 *route53.CreateVPCAssociationAuthorizationInput, arg2 ...request.Option) (*route53.CreateVPCAssociationAuthorizationOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorizationWithContext", varargs...)
	ret0, _ := ret[0].(*route53.CreateVPCAssociationAuthorizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVPCAssociationAuthorizationWithContext indicates an expected call of CreateVPCAssociationAuthorizationWithContext
func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorizationWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorizationWithContext), varargs...)
}

// CreateVPCAssociationAuthorizationRequest mocks base method
func (m *MockRoute53API) CreateVPCAssociationAuthorizationRequest(arg0 *route53.CreateVPCAssociationAuthorizationInput) (*request.Request, *route53.CreateVPCAssociationAuthorizationOutput) {
	ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.CreateVPCAssociationAuthorizationOutput)
	return ret0, ret1
}

// CreateVPCAssociationAuthorizationRequest indicates an expected call of CreateVPCAssociationAuthorizationRequest
func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorizationRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorizationRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorizationRequest), arg0)
}

// DeleteHealthCheck mocks base method
func (m *MockRoute53API) DeleteHealthCheck(arg0 *route53.DeleteHealthCheckInput) (*route53.DeleteHealthCheckOutput, error) {
	ret := m.ctrl.Call(m, "DeleteHealthCheck", arg0)
	ret0, _ := ret[0].(*route53.DeleteHealthCheckOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteHealthCheck indicates an expected call of DeleteHealthCheck
func (mr *MockRoute53APIMockRecorder) DeleteHealthCheck(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheck), arg0)
}

// DeleteHealthCheckWithContext mocks base method
func (m *MockRoute53API) DeleteHealthCheckWithContext(arg0 aws.Context, arg1 *route53.DeleteHealthCheckInput, arg2 ...request.Option) (*route53.DeleteHealthCheckOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteHealthCheckWithContext", varargs...)
	ret0, _ := ret[0].(*route53.DeleteHealthCheckOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteHealthCheckWithContext indicates an expected call of DeleteHealthCheckWithContext
func (mr *MockRoute53APIMockRecorder) DeleteHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheckWithContext), varargs...)
}

// DeleteHealthCheckRequest mocks base method
func (m *MockRoute53API) DeleteHealthCheckRequest(arg0 *route53.DeleteHealthCheckInput) (*request.Request, *route53.DeleteHealthCheckOutput) {
	ret := m.ctrl.Call(m, "DeleteHealthCheckRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.DeleteHealthCheckOutput)
	return ret0, ret1
}

// DeleteHealthCheckRequest indicates an expected call of DeleteHealthCheckRequest
func (mr *MockRoute53APIMockRecorder) DeleteHealthCheckRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheckRequest), arg0)
}

// DeleteHostedZone mocks base method
func (m *MockRoute53API) DeleteHostedZone(arg0 *route53.DeleteHostedZoneInput) (*route53.DeleteHostedZoneOutput, error) {
	ret := m.ctrl.Call(m, "DeleteHostedZone", arg0)
	ret0, _ := ret[0].(*route53.DeleteHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteHostedZone indicates an expected call of DeleteHostedZone
func (mr *MockRoute53APIMockRecorder) DeleteHostedZone(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZone", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZone), arg0)
}

// DeleteHostedZoneWithContext mocks base method
func (m *MockRoute53API) DeleteHostedZoneWithContext(arg0 aws.Context, arg1 *route53.DeleteHostedZoneInput, arg2 ...request.Option) (*route53.DeleteHostedZoneOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteHostedZoneWithContext", varargs...)
	ret0, _ := ret[0].(*route53.DeleteHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteHostedZoneWithContext indicates an expected call of DeleteHostedZoneWithContext
func (mr *MockRoute53APIMockRecorder) DeleteHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZoneWithContext), varargs...)
}

// DeleteHostedZoneRequest mocks base method
func (m *MockRoute53API) DeleteHostedZoneRequest(arg0 *route53.DeleteHostedZoneInput) (*request.Request, *route53.DeleteHostedZoneOutput) {
	ret := m.ctrl.Call(m, "DeleteHostedZoneRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.DeleteHostedZoneOutput)
	return ret0, ret1
}

// DeleteHostedZoneRequest indicates an expected call of DeleteHostedZoneRequest
func (mr *MockRoute53APIMockRecorder) DeleteHostedZoneRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZoneRequest), arg0)
}

// DeleteQueryLoggingConfig mocks base method
func (m *MockRoute53API) DeleteQueryLoggingConfig(arg0 *route53.DeleteQueryLoggingConfigInput) (*route53.DeleteQueryLoggingConfigOutput, error) {
	ret := m.ctrl.Call(m, "DeleteQueryLoggingConfig", arg0)
	ret0, _ := ret[0].(*route53.DeleteQueryLoggingConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteQueryLoggingConfig indicates an expected call of DeleteQueryLoggingConfig
func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfig(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfig), arg0)
}

// DeleteQueryLoggingConfigWithContext mocks base method
func (m *MockRoute53API) DeleteQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.DeleteQueryLoggingConfigInput, arg2 ...request.Option) (*route53.DeleteQueryLoggingConfigOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteQueryLoggingConfigWithContext", varargs...)
	ret0, _ := ret[0].(*route53.DeleteQueryLoggingConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteQueryLoggingConfigWithContext indicates an expected call of DeleteQueryLoggingConfigWithContext
func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfigWithContext), varargs...)
}

// DeleteQueryLoggingConfigRequest mocks base method
func (m *MockRoute53API) DeleteQueryLoggingConfigRequest(arg0 *route53.DeleteQueryLoggingConfigInput) (*request.Request, *route53.DeleteQueryLoggingConfigOutput) {
	ret := m.ctrl.Call(m, "DeleteQueryLoggingConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.DeleteQueryLoggingConfigOutput)
	return ret0, ret1
}

// DeleteQueryLoggingConfigRequest indicates an expected call of DeleteQueryLoggingConfigRequest
func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfigRequest), arg0)
}

// DeleteReusableDelegationSet mocks base method
func (m *MockRoute53API) DeleteReusableDelegationSet(arg0 *route53.DeleteReusableDelegationSetInput) (*route53.DeleteReusableDelegationSetOutput, error) {
	ret := m.ctrl.Call(m, "DeleteReusableDelegationSet", arg0)
	ret0, _ := ret[0].(*route53.DeleteReusableDelegationSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteReusableDelegationSet indicates an expected call of DeleteReusableDelegationSet
func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSet(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSet), arg0)
}

// DeleteReusableDelegationSetWithContext mocks base method
func (m *MockRoute53API) DeleteReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.DeleteReusableDelegationSetInput, arg2 ...request.Option) (*route53.DeleteReusableDelegationSetOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteReusableDelegationSetWithContext", varargs...)
	ret0, _ := ret[0].(*route53.DeleteReusableDelegationSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteReusableDelegationSetWithContext indicates an expected call of DeleteReusableDelegationSetWithContext
func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSetWithContext), varargs...)
}

// DeleteReusableDelegationSetRequest mocks base method
func (m *MockRoute53API) DeleteReusableDelegationSetRequest(arg0 *route53.DeleteReusableDelegationSetInput) (*request.Request, *route53.DeleteReusableDelegationSetOutput) {
	ret := m.ctrl.Call(m, "DeleteReusableDelegationSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.DeleteReusableDelegationSetOutput)
	return ret0, ret1
}

// DeleteReusableDelegationSetRequest indicates an expected call of DeleteReusableDelegationSetRequest
func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSetRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSetRequest), arg0)
}

// DeleteTrafficPolicy mocks base method
func (m *MockRoute53API) DeleteTrafficPolicy(arg0 *route53.DeleteTrafficPolicyInput) (*route53.DeleteTrafficPolicyOutput, error) {
	ret := m.ctrl.Call(m, "DeleteTrafficPolicy", arg0)
	ret0, _ := ret[0].(*route53.DeleteTrafficPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrafficPolicy indicates an expected call of DeleteTrafficPolicy
func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicy(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicy), arg0)
}

// DeleteTrafficPolicyWithContext mocks base method
func (m *MockRoute53API) DeleteTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.DeleteTrafficPolicyInput, arg2 ...request.Option) (*route53.DeleteTrafficPolicyOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTrafficPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*route53.DeleteTrafficPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrafficPolicyWithContext indicates an expected call of DeleteTrafficPolicyWithContext
func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyWithContext), varargs...)
}

// DeleteTrafficPolicyRequest mocks base method
func (m *MockRoute53API) DeleteTrafficPolicyRequest(arg0 *route53.DeleteTrafficPolicyInput) (*request.Request, *route53.DeleteTrafficPolicyOutput) {
	ret := m.ctrl.Call(m, "DeleteTrafficPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.DeleteTrafficPolicyOutput)
	return ret0, ret1
}

// DeleteTrafficPolicyRequest indicates an expected call of DeleteTrafficPolicyRequest
func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyRequest), arg0)
}

// DeleteTrafficPolicyInstance mocks base method
func (m *MockRoute53API) DeleteTrafficPolicyInstance(arg0 *route53.DeleteTrafficPolicyInstanceInput) (*route53.DeleteTrafficPolicyInstanceOutput, error) {
	ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstance", arg0)
	ret0, _ := ret[0].(*route53.DeleteTrafficPolicyInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrafficPolicyInstance indicates an expected call of DeleteTrafficPolicyInstance
func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstance(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstance), arg0)
}

// DeleteTrafficPolicyInstanceWithContext mocks base method
func (m *MockRoute53API) DeleteTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.DeleteTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.DeleteTrafficPolicyInstanceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*route53.DeleteTrafficPolicyInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrafficPolicyInstanceWithContext indicates an expected call of DeleteTrafficPolicyInstanceWithContext
func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstanceWithContext), varargs...)
}

// DeleteTrafficPolicyInstanceRequest mocks base method
func (m *MockRoute53API) DeleteTrafficPolicyInstanceRequest(arg0 *route53.DeleteTrafficPolicyInstanceInput) (*request.Request, *route53.DeleteTrafficPolicyInstanceOutput) {
	ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.DeleteTrafficPolicyInstanceOutput)
	return ret0, ret1
}

// DeleteTrafficPolicyInstanceRequest indicates an expected call of DeleteTrafficPolicyInstanceRequest
func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstanceRequest), arg0)
}

// DeleteVPCAssociationAuthorization mocks base method
func (m *MockRoute53API) DeleteVPCAssociationAuthorization(arg0 *route53.DeleteVPCAssociationAuthorizationInput) (*route53.DeleteVPCAssociationAuthorizationOutput, error) {
	ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorization", arg0)
	ret0, _ := ret[0].(*route53.DeleteVPCAssociationAuthorizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVPCAssociationAuthorization indicates an expected call of DeleteVPCAssociationAuthorization
func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorization(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorization", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorization), arg0)
}

// DeleteVPCAssociationAuthorizationWithContext mocks base method
func (m *MockRoute53API) DeleteVPCAssociationAuthorizationWithContext(arg0 aws.Context, arg1 *route53.DeleteVPCAssociationAuthorizationInput, arg2 ...request.Option) (*route53.DeleteVPCAssociationAuthorizationOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorizationWithContext", varargs...)
	ret0, _ := ret[0].(*route53.DeleteVPCAssociationAuthorizationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVPCAssociationAuthorizationWithContext indicates an expected call of DeleteVPCAssociationAuthorizationWithContext
func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorizationWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorizationWithContext), varargs...)
}

// DeleteVPCAssociationAuthorizationRequest mocks base method
func (m *MockRoute53API) DeleteVPCAssociationAuthorizationRequest(arg0 *route53.DeleteVPCAssociationAuthorizationInput) (*request.Request, *route53.DeleteVPCAssociationAuthorizationOutput) {
	ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorizationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.DeleteVPCAssociationAuthorizationOutput)
	return ret0, ret1
}

// DeleteVPCAssociationAuthorizationRequest indicates an expected call of DeleteVPCAssociationAuthorizationRequest
func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorizationRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorizationRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorizationRequest), arg0)
}

// DisassociateVPCFromHostedZone mocks base method
func (m *MockRoute53API) DisassociateVPCFromHostedZone(arg0 *route53.DisassociateVPCFromHostedZoneInput) (*route53.DisassociateVPCFromHostedZoneOutput, error) {
	ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZone", arg0)
	ret0, _ := ret[0].(*route53.DisassociateVPCFromHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateVPCFromHostedZone indicates an expected call of DisassociateVPCFromHostedZone
func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZone(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZone", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZone), arg0)
}

// DisassociateVPCFromHostedZoneWithContext mocks base method
func (m *MockRoute53API) DisassociateVPCFromHostedZoneWithContext(arg0 aws.Context, arg1 *route53.DisassociateVPCFromHostedZoneInput, arg2 ...request.Option) (*route53.DisassociateVPCFromHostedZoneOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZoneWithContext", varargs...)
	ret0, _ := ret[0].(*route53.DisassociateVPCFromHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateVPCFromHostedZoneWithContext indicates an expected call of DisassociateVPCFromHostedZoneWithContext
func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZoneWithContext), varargs...)
}

// DisassociateVPCFromHostedZoneRequest mocks base method
func (m *MockRoute53API) DisassociateVPCFromHostedZoneRequest(arg0 *route53.DisassociateVPCFromHostedZoneInput) (*request.Request, *route53.DisassociateVPCFromHostedZoneOutput) {
	ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZoneRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.DisassociateVPCFromHostedZoneOutput)
	return ret0, ret1
}

// DisassociateVPCFromHostedZoneRequest indicates an expected call of DisassociateVPCFromHostedZoneRequest
func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZoneRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZoneRequest), arg0)
}

// GetAccountLimit mocks base method
func (m *MockRoute53API) GetAccountLimit(arg0 *route53.GetAccountLimitInput) (*route53.GetAccountLimitOutput, error) {
	ret := m.ctrl.Call(m, "GetAccountLimit", arg0)
	ret0, _ := ret[0].(*route53.GetAccountLimitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountLimit indicates an expected call of GetAccountLimit
func (mr *MockRoute53APIMockRecorder) GetAccountLimit(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimit", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimit), arg0)
}

// GetAccountLimitWithContext mocks base method
func (m *MockRoute53API) GetAccountLimitWithContext(arg0 aws.Context, arg1 *route53.GetAccountLimitInput, arg2 ...request.Option) (*route53.GetAccountLimitOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAccountLimitWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetAccountLimitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountLimitWithContext indicates an expected call of GetAccountLimitWithContext
func (mr *MockRoute53APIMockRecorder) GetAccountLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimitWithContext), varargs...)
}

// GetAccountLimitRequest mocks base method
func (m *MockRoute53API) GetAccountLimitRequest(arg0 *route53.GetAccountLimitInput) (*request.Request, *route53.GetAccountLimitOutput) {
	ret := m.ctrl.Call(m, "GetAccountLimitRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetAccountLimitOutput)
	return ret0, ret1
}

// GetAccountLimitRequest indicates an expected call of GetAccountLimitRequest
func (mr *MockRoute53APIMockRecorder) GetAccountLimitRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimitRequest), arg0)
}

// GetChange mocks base method
func (m *MockRoute53API) GetChange(arg0 *route53.GetChangeInput) (*route53.GetChangeOutput, error) {
	ret := m.ctrl.Call(m, "GetChange", arg0)
	ret0, _ := ret[0].(*route53.GetChangeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChange indicates an expected call of GetChange
func (mr *MockRoute53APIMockRecorder) GetChange(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChange", reflect.TypeOf((*MockRoute53API)(nil).GetChange), arg0)
}

// GetChangeWithContext mocks base method
func (m *MockRoute53API) GetChangeWithContext(arg0 aws.Context, arg1 *route53.GetChangeInput, arg2 ...request.Option) (*route53.GetChangeOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetChangeWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetChangeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChangeWithContext indicates an expected call of GetChangeWithContext
func (mr *MockRoute53APIMockRecorder) GetChangeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangeWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetChangeWithContext), varargs...)
}

// GetChangeRequest mocks base method
func (m *MockRoute53API) GetChangeRequest(arg0 *route53.GetChangeInput) (*request.Request, *route53.GetChangeOutput) {
	ret := m.ctrl.Call(m, "GetChangeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetChangeOutput)
	return ret0, ret1
}

// GetChangeRequest indicates an expected call of GetChangeRequest
func (mr *MockRoute53APIMockRecorder) GetChangeRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangeRequest", reflect.TypeOf((*MockRoute53API)(nil).GetChangeRequest), arg0)
}

// GetCheckerIpRanges mocks base method
func (m *MockRoute53API) GetCheckerIpRanges(arg0 *route53.GetCheckerIpRangesInput) (*route53.GetCheckerIpRangesOutput, error) {
	ret := m.ctrl.Call(m, "GetCheckerIpRanges", arg0)
	ret0, _ := ret[0].(*route53.GetCheckerIpRangesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCheckerIpRanges indicates an expected call of GetCheckerIpRanges
func (mr *MockRoute53APIMockRecorder) GetCheckerIpRanges(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRanges", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRanges), arg0)
}

// GetCheckerIpRangesWithContext mocks base method
func (m *MockRoute53API) GetCheckerIpRangesWithContext(arg0 aws.Context, arg1 *route53.GetCheckerIpRangesInput, arg2 ...request.Option) (*route53.GetCheckerIpRangesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCheckerIpRangesWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetCheckerIpRangesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCheckerIpRangesWithContext indicates an expected call of GetCheckerIpRangesWithContext
func (mr *MockRoute53APIMockRecorder) GetCheckerIpRangesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRangesWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRangesWithContext), varargs...)
}

// GetCheckerIpRangesRequest mocks base method
func (m *MockRoute53API) GetCheckerIpRangesRequest(arg0 *route53.GetCheckerIpRangesInput) (*request.Request, *route53.GetCheckerIpRangesOutput) {
	ret := m.ctrl.Call(m, "GetCheckerIpRangesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetCheckerIpRangesOutput)
	return ret0, ret1
}

// GetCheckerIpRangesRequest indicates an expected call of GetCheckerIpRangesRequest
func (mr *MockRoute53APIMockRecorder) GetCheckerIpRangesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRangesRequest", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRangesRequest), arg0)
}

// GetGeoLocation mocks base method
func (m *MockRoute53API) GetGeoLocation(arg0 *route53.GetGeoLocationInput) (*route53.GetGeoLocationOutput, error) {
	ret := m.ctrl.Call(m, "GetGeoLocation", arg0)
	ret0, _ := ret[0].(*route53.GetGeoLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGeoLocation indicates an expected call of GetGeoLocation
func (mr *MockRoute53APIMockRecorder) GetGeoLocation(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocation", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocation), arg0)
}

// GetGeoLocationWithContext mocks base method
func (m *MockRoute53API) GetGeoLocationWithContext(arg0 aws.Context, arg1 *route53.GetGeoLocationInput, arg2 ...request.Option) (*route53.GetGeoLocationOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGeoLocationWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetGeoLocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGeoLocationWithContext indicates an expected call of GetGeoLocationWithContext
func (mr *MockRoute53APIMockRecorder) GetGeoLocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocationWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocationWithContext), varargs...)
}

// GetGeoLocationRequest mocks base method
func (m *MockRoute53API) GetGeoLocationRequest(arg0 *route53.GetGeoLocationInput) (*request.Request, *route53.GetGeoLocationOutput) {
	ret := m.ctrl.Call(m, "GetGeoLocationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetGeoLocationOutput)
	return ret0, ret1
}

// GetGeoLocationRequest indicates an expected call of GetGeoLocationRequest
func (mr *MockRoute53APIMockRecorder) GetGeoLocationRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocationRequest", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocationRequest), arg0)
}

// GetHealthCheck mocks base method
func (m *MockRoute53API) GetHealthCheck(arg0 *route53.GetHealthCheckInput) (*route53.GetHealthCheckOutput, error) {
	ret := m.ctrl.Call(m, "GetHealthCheck", arg0)
	ret0, _ := ret[0].(*route53.GetHealthCheckOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHealthCheck indicates an expected call of GetHealthCheck
func (mr *MockRoute53APIMockRecorder) GetHealthCheck(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheck), arg0)
}

// GetHealthCheckWithContext mocks base method
func (m *MockRoute53API) GetHealthCheckWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckInput, arg2 ...request.Option) (*route53.GetHealthCheckOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetHealthCheckWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetHealthCheckOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHealthCheckWithContext indicates an expected call of GetHealthCheckWithContext
func (mr *MockRoute53APIMockRecorder) GetHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckWithContext), varargs...)
}

// GetHealthCheckRequest mocks base method
func (m *MockRoute53API) GetHealthCheckRequest(arg0 *route53.GetHealthCheckInput) (*request.Request, *route53.GetHealthCheckOutput) {
	ret := m.ctrl.Call(m, "GetHealthCheckRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetHealthCheckOutput)
	return ret0, ret1
}

// GetHealthCheckRequest indicates an expected call of GetHealthCheckRequest
func (mr *MockRoute53APIMockRecorder) GetHealthCheckRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckRequest), arg0)
}

// GetHealthCheckCount mocks base method
func (m *MockRoute53API) GetHealthCheckCount(arg0 *route53.GetHealthCheckCountInput) (*route53.GetHealthCheckCountOutput, error) {
	ret := m.ctrl.Call(m, "GetHealthCheckCount", arg0)
	ret0, _ := ret[0].(*route53.GetHealthCheckCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHealthCheckCount indicates an expected call of GetHealthCheckCount
func (mr *MockRoute53APIMockRecorder) GetHealthCheckCount(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCount", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCount), arg0)
}

// GetHealthCheckCountWithContext mocks base method
func (m *MockRoute53API) GetHealthCheckCountWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckCountInput, arg2 ...request.Option) (*route53.GetHealthCheckCountOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetHealthCheckCountWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetHealthCheckCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHealthCheckCountWithContext indicates an expected call of GetHealthCheckCountWithContext
func (mr *MockRoute53APIMockRecorder) GetHealthCheckCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCountWithContext), varargs...)
}

// GetHealthCheckCountRequest mocks base method
func (m *MockRoute53API) GetHealthCheckCountRequest(arg0 *route53.GetHealthCheckCountInput) (*request.Request, *route53.GetHealthCheckCountOutput) {
	ret := m.ctrl.Call(m, "GetHealthCheckCountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetHealthCheckCountOutput)
	return ret0, ret1
}

// GetHealthCheckCountRequest indicates an expected call of GetHealthCheckCountRequest
func (mr *MockRoute53APIMockRecorder) GetHealthCheckCountRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCountRequest), arg0)
}

// GetHealthCheckLastFailureReason mocks base method
func (m *MockRoute53API) GetHealthCheckLastFailureReason(arg0 *route53.GetHealthCheckLastFailureReasonInput) (*route53.GetHealthCheckLastFailureReasonOutput, error) {
	ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReason", arg0)
	ret0, _ := ret[0].(*route53.GetHealthCheckLastFailureReasonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHealthCheckLastFailureReason indicates an expected call of GetHealthCheckLastFailureReason
func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReason(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReason", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReason), arg0)
}

// GetHealthCheckLastFailureReasonWithContext mocks base method
func (m *MockRoute53API) GetHealthCheckLastFailureReasonWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckLastFailureReasonInput, arg2 ...request.Option) (*route53.GetHealthCheckLastFailureReasonOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReasonWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetHealthCheckLastFailureReasonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHealthCheckLastFailureReasonWithContext indicates an expected call of GetHealthCheckLastFailureReasonWithContext
func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReasonWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReasonWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReasonWithContext), varargs...)
}

// GetHealthCheckLastFailureReasonRequest mocks base method
func (m *MockRoute53API) GetHealthCheckLastFailureReasonRequest(arg0 *route53.GetHealthCheckLastFailureReasonInput) (*request.Request, *route53.GetHealthCheckLastFailureReasonOutput) {
	ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReasonRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetHealthCheckLastFailureReasonOutput)
	return ret0, ret1
}

// GetHealthCheckLastFailureReasonRequest indicates an expected call of GetHealthCheckLastFailureReasonRequest
func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReasonRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReasonRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReasonRequest), arg0)
}

// GetHealthCheckStatus mocks base method
func (m *MockRoute53API) GetHealthCheckStatus(arg0 *route53.GetHealthCheckStatusInput) (*route53.GetHealthCheckStatusOutput, error) {
	ret := m.ctrl.Call(m, "GetHealthCheckStatus", arg0)
	ret0, _ := ret[0].(*route53.GetHealthCheckStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHealthCheckStatus indicates an expected call of GetHealthCheckStatus
func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatus(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatus", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatus), arg0)
}

// GetHealthCheckStatusWithContext mocks base method
func (m *MockRoute53API) GetHealthCheckStatusWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckStatusInput, arg2 ...request.Option) (*route53.GetHealthCheckStatusOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetHealthCheckStatusWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetHealthCheckStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHealthCheckStatusWithContext indicates an expected call of GetHealthCheckStatusWithContext
func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatusWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatusWithContext), varargs...)
}

// GetHealthCheckStatusRequest mocks base method
func (m *MockRoute53API) GetHealthCheckStatusRequest(arg0 *route53.GetHealthCheckStatusInput) (*request.Request, *route53.GetHealthCheckStatusOutput) {
	ret := m.ctrl.Call(m, "GetHealthCheckStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetHealthCheckStatusOutput)
	return ret0, ret1
}

// GetHealthCheckStatusRequest indicates an expected call of GetHealthCheckStatusRequest
func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatusRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatusRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatusRequest), arg0)
}

// GetHostedZone mocks base method
func (m *MockRoute53API) GetHostedZone(arg0 *route53.GetHostedZoneInput) (*route53.GetHostedZoneOutput, error) {
	ret := m.ctrl.Call(m, "GetHostedZone", arg0)
	ret0, _ := ret[0].(*route53.GetHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostedZone indicates an expected call of GetHostedZone
func (mr *MockRoute53APIMockRecorder) GetHostedZone(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZone", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZone), arg0)
}

// GetHostedZoneWithContext mocks base method
func (m *MockRoute53API) GetHostedZoneWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneInput, arg2 ...request.Option) (*route53.GetHostedZoneOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetHostedZoneWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostedZoneWithContext indicates an expected call of GetHostedZoneWithContext
func (mr *MockRoute53APIMockRecorder) GetHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneWithContext), varargs...)
}

// GetHostedZoneRequest mocks base method
func (m *MockRoute53API) GetHostedZoneRequest(arg0 *route53.GetHostedZoneInput) (*request.Request, *route53.GetHostedZoneOutput) {
	ret := m.ctrl.Call(m, "GetHostedZoneRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetHostedZoneOutput)
	return ret0, ret1
}

// GetHostedZoneRequest indicates an expected call of GetHostedZoneRequest
func (mr *MockRoute53APIMockRecorder) GetHostedZoneRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneRequest), arg0)
}

// GetHostedZoneCount mocks base method
func (m *MockRoute53API) GetHostedZoneCount(arg0 *route53.GetHostedZoneCountInput) (*route53.GetHostedZoneCountOutput, error) {
	ret := m.ctrl.Call(m, "GetHostedZoneCount", arg0)
	ret0, _ := ret[0].(*route53.GetHostedZoneCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostedZoneCount indicates an expected call of GetHostedZoneCount
func (mr *MockRoute53APIMockRecorder) GetHostedZoneCount(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCount", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCount), arg0)
}

// GetHostedZoneCountWithContext mocks base method
func (m *MockRoute53API) GetHostedZoneCountWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneCountInput, arg2 ...request.Option) (*route53.GetHostedZoneCountOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetHostedZoneCountWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetHostedZoneCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostedZoneCountWithContext indicates an expected call of GetHostedZoneCountWithContext
func (mr *MockRoute53APIMockRecorder) GetHostedZoneCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCountWithContext), varargs...)
}

// GetHostedZoneCountRequest mocks base method
func (m *MockRoute53API) GetHostedZoneCountRequest(arg0 *route53.GetHostedZoneCountInput) (*request.Request, *route53.GetHostedZoneCountOutput) {
	ret := m.ctrl.Call(m, "GetHostedZoneCountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetHostedZoneCountOutput)
	return ret0, ret1
}

// GetHostedZoneCountRequest indicates an expected call of GetHostedZoneCountRequest
func (mr *MockRoute53APIMockRecorder) GetHostedZoneCountRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCountRequest), arg0)
}

// GetHostedZoneLimit mocks base method
func (m *MockRoute53API) GetHostedZoneLimit(arg0 *route53.GetHostedZoneLimitInput) (*route53.GetHostedZoneLimitOutput, error) {
	ret := m.ctrl.Call(m, "GetHostedZoneLimit", arg0)
	ret0, _ := ret[0].(*route53.GetHostedZoneLimitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostedZoneLimit indicates an expected call of GetHostedZoneLimit
func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimit(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimit", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimit), arg0)
}

// GetHostedZoneLimitWithContext mocks base method
func (m *MockRoute53API) GetHostedZoneLimitWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneLimitInput, arg2 ...request.Option) (*route53.GetHostedZoneLimitOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetHostedZoneLimitWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetHostedZoneLimitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostedZoneLimitWithContext indicates an expected call of GetHostedZoneLimitWithContext
func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimitWithContext), varargs...)
}

// GetHostedZoneLimitRequest mocks base method
func (m *MockRoute53API) GetHostedZoneLimitRequest(arg0 *route53.GetHostedZoneLimitInput) (*request.Request, *route53.GetHostedZoneLimitOutput) {
	ret := m.ctrl.Call(m, "GetHostedZoneLimitRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetHostedZoneLimitOutput)
	return ret0, ret1
}

// GetHostedZoneLimitRequest indicates an expected call of GetHostedZoneLimitRequest
func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimitRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimitRequest), arg0)
}

// GetQueryLoggingConfig mocks base method
func (m *MockRoute53API) GetQueryLoggingConfig(arg0 *route53.GetQueryLoggingConfigInput) (*route53.GetQueryLoggingConfigOutput, error) {
	ret := m.ctrl.Call(m, "GetQueryLoggingConfig", arg0)
	ret0, _ := ret[0].(*route53.GetQueryLoggingConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueryLoggingConfig indicates an expected call of GetQueryLoggingConfig
func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfig(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfig), arg0)
}

// GetQueryLoggingConfigWithContext mocks base method
func (m *MockRoute53API) GetQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.GetQueryLoggingConfigInput, arg2 ...request.Option) (*route53.GetQueryLoggingConfigOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetQueryLoggingConfigWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetQueryLoggingConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueryLoggingConfigWithContext indicates an expected call of GetQueryLoggingConfigWithContext
func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfigWithContext), varargs...)
}

// GetQueryLoggingConfigRequest mocks base method
func (m *MockRoute53API) GetQueryLoggingConfigRequest(arg0 *route53.GetQueryLoggingConfigInput) (*request.Request, *route53.GetQueryLoggingConfigOutput) {
	ret := m.ctrl.Call(m, "GetQueryLoggingConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetQueryLoggingConfigOutput)
	return ret0, ret1
}

// GetQueryLoggingConfigRequest indicates an expected call of GetQueryLoggingConfigRequest
func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfigRequest), arg0)
}

// GetReusableDelegationSet mocks base method
func (m *MockRoute53API) GetReusableDelegationSet(arg0 *route53.GetReusableDelegationSetInput) (*route53.GetReusableDelegationSetOutput, error) {
	ret := m.ctrl.Call(m, "GetReusableDelegationSet", arg0)
	ret0, _ := ret[0].(*route53.GetReusableDelegationSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReusableDelegationSet indicates an expected call of GetReusableDelegationSet
func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSet(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSet), arg0)
}

// GetReusableDelegationSetWithContext mocks base method
func (m *MockRoute53API) GetReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.GetReusableDelegationSetInput, arg2 ...request.Option) (*route53.GetReusableDelegationSetOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetReusableDelegationSetWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetReusableDelegationSetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReusableDelegationSetWithContext indicates an expected call of GetReusableDelegationSetWithContext
func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetWithContext), varargs...)
}

// GetReusableDelegationSetRequest mocks base method
func (m *MockRoute53API) GetReusableDelegationSetRequest(arg0 *route53.GetReusableDelegationSetInput) (*request.Request, *route53.GetReusableDelegationSetOutput) {
	ret := m.ctrl.Call(m, "GetReusableDelegationSetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetReusableDelegationSetOutput)
	return ret0, ret1
}

// GetReusableDelegationSetRequest indicates an expected call of GetReusableDelegationSetRequest
func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetRequest), arg0)
}

// GetReusableDelegationSetLimit mocks base method
func (m *MockRoute53API) GetReusableDelegationSetLimit(arg0 *route53.GetReusableDelegationSetLimitInput) (*route53.GetReusableDelegationSetLimitOutput, error) {
	ret := m.ctrl.Call(m, "GetReusableDelegationSetLimit", arg0)
	ret0, _ := ret[0].(*route53.GetReusableDelegationSetLimitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReusableDelegationSetLimit indicates an expected call of GetReusableDelegationSetLimit
func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimit(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimit", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimit), arg0)
}

// GetReusableDelegationSetLimitWithContext mocks base method
func (m *MockRoute53API) GetReusableDelegationSetLimitWithContext(arg0 aws.Context, arg1 *route53.GetReusableDelegationSetLimitInput, arg2 ...request.Option) (*route53.GetReusableDelegationSetLimitOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetReusableDelegationSetLimitWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetReusableDelegationSetLimitOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReusableDelegationSetLimitWithContext indicates an expected call of GetReusableDelegationSetLimitWithContext
func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimitWithContext), varargs...)
}

// GetReusableDelegationSetLimitRequest mocks base method
func (m *MockRoute53API) GetReusableDelegationSetLimitRequest(arg0 *route53.GetReusableDelegationSetLimitInput) (*request.Request, *route53.GetReusableDelegationSetLimitOutput) {
	ret := m.ctrl.Call(m, "GetReusableDelegationSetLimitRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetReusableDelegationSetLimitOutput)
	return ret0, ret1
}

// GetReusableDelegationSetLimitRequest indicates an expected call of GetReusableDelegationSetLimitRequest
func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimitRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimitRequest), arg0)
}

// GetTrafficPolicy mocks base method
func (m *MockRoute53API) GetTrafficPolicy(arg0 *route53.GetTrafficPolicyInput) (*route53.GetTrafficPolicyOutput, error) {
	ret := m.ctrl.Call(m, "GetTrafficPolicy", arg0)
	ret0, _ := ret[0].(*route53.GetTrafficPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTrafficPolicy indicates an expected call of GetTrafficPolicy
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicy(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicy), arg0)
}

// GetTrafficPolicyWithContext mocks base method
func (m *MockRoute53API) GetTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInput, arg2 ...request.Option) (*route53.GetTrafficPolicyOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTrafficPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetTrafficPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTrafficPolicyWithContext indicates an expected call of GetTrafficPolicyWithContext
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyWithContext), varargs...)
}

// GetTrafficPolicyRequest mocks base method
func (m *MockRoute53API) GetTrafficPolicyRequest(arg0 *route53.GetTrafficPolicyInput) (*request.Request, *route53.GetTrafficPolicyOutput) {
	ret := m.ctrl.Call(m, "GetTrafficPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetTrafficPolicyOutput)
	return ret0, ret1
}

// GetTrafficPolicyRequest indicates an expected call of GetTrafficPolicyRequest
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyRequest), arg0)
}

// GetTrafficPolicyInstance mocks base method
func (m *MockRoute53API) GetTrafficPolicyInstance(arg0 *route53.GetTrafficPolicyInstanceInput) (*route53.GetTrafficPolicyInstanceOutput, error) {
	ret := m.ctrl.Call(m, "GetTrafficPolicyInstance", arg0)
	ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTrafficPolicyInstance indicates an expected call of GetTrafficPolicyInstance
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstance(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstance), arg0)
}

// GetTrafficPolicyInstanceWithContext mocks base method
func (m *MockRoute53API) GetTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.GetTrafficPolicyInstanceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTrafficPolicyInstanceWithContext indicates an expected call of GetTrafficPolicyInstanceWithContext
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceWithContext), varargs...)
}

// GetTrafficPolicyInstanceRequest mocks base method
func (m *MockRoute53API) GetTrafficPolicyInstanceRequest(arg0 *route53.GetTrafficPolicyInstanceInput) (*request.Request, *route53.GetTrafficPolicyInstanceOutput) {
	ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetTrafficPolicyInstanceOutput)
	return ret0, ret1
}

// GetTrafficPolicyInstanceRequest indicates an expected call of GetTrafficPolicyInstanceRequest
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceRequest), arg0)
}

// GetTrafficPolicyInstanceCount mocks base method
func (m *MockRoute53API) GetTrafficPolicyInstanceCount(arg0 *route53.GetTrafficPolicyInstanceCountInput) (*route53.GetTrafficPolicyInstanceCountOutput, error) {
	ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCount", arg0)
	ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTrafficPolicyInstanceCount indicates an expected call of GetTrafficPolicyInstanceCount
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCount(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCount", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCount), arg0)
}

// GetTrafficPolicyInstanceCountWithContext mocks base method
func (m *MockRoute53API) GetTrafficPolicyInstanceCountWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInstanceCountInput, arg2 ...request.Option) (*route53.GetTrafficPolicyInstanceCountOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCountWithContext", varargs...)
	ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceCountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTrafficPolicyInstanceCountWithContext indicates an expected call of GetTrafficPolicyInstanceCountWithContext
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCountWithContext), varargs...)
}

// GetTrafficPolicyInstanceCountRequest mocks base method
func (m *MockRoute53API) GetTrafficPolicyInstanceCountRequest(arg0 *route53.GetTrafficPolicyInstanceCountInput) (*request.Request, *route53.GetTrafficPolicyInstanceCountOutput) {
	ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.GetTrafficPolicyInstanceCountOutput)
	return ret0, ret1
}

// GetTrafficPolicyInstanceCountRequest indicates an expected call of GetTrafficPolicyInstanceCountRequest
func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCountRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCountRequest), arg0)
}

// ListGeoLocations mocks base method
func (m *MockRoute53API) ListGeoLocations(arg0 *route53.ListGeoLocationsInput) (*route53.ListGeoLocationsOutput, error) {
	ret := m.ctrl.Call(m, "ListGeoLocations", arg0)
	ret0, _ := ret[0].(*route53.ListGeoLocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGeoLocations indicates an expected call of ListGeoLocations
func (mr *MockRoute53APIMockRecorder) ListGeoLocations(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocations", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocations), arg0)
}

// ListGeoLocationsWithContext mocks base method
func (m *MockRoute53API) ListGeoLocationsWithContext(arg0 aws.Context, arg1 *route53.ListGeoLocationsInput, arg2 ...request.Option) (*route53.ListGeoLocationsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGeoLocationsWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListGeoLocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGeoLocationsWithContext indicates an expected call of ListGeoLocationsWithContext
func (mr *MockRoute53APIMockRecorder) ListGeoLocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocationsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocationsWithContext), varargs...)
}

// ListGeoLocationsRequest mocks base method
func (m *MockRoute53API) ListGeoLocationsRequest(arg0 *route53.ListGeoLocationsInput) (*request.Request, *route53.ListGeoLocationsOutput) {
	ret := m.ctrl.Call(m, "ListGeoLocationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListGeoLocationsOutput)
	return ret0, ret1
}

// ListGeoLocationsRequest indicates an expected call of ListGeoLocationsRequest
func (mr *MockRoute53APIMockRecorder) ListGeoLocationsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocationsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocationsRequest), arg0)
}

// ListHealthChecks mocks base method
func (m *MockRoute53API) ListHealthChecks(arg0 *route53.ListHealthChecksInput) (*route53.ListHealthChecksOutput, error) {
	ret := m.ctrl.Call(m, "ListHealthChecks", arg0)
	ret0, _ := ret[0].(*route53.ListHealthChecksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHealthChecks indicates an expected call of ListHealthChecks
func (mr *MockRoute53APIMockRecorder) ListHealthChecks(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecks", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecks), arg0)
}

// ListHealthChecksWithContext mocks base method
func (m *MockRoute53API) ListHealthChecksWithContext(arg0 aws.Context, arg1 *route53.ListHealthChecksInput, arg2 ...request.Option) (*route53.ListHealthChecksOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHealthChecksWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListHealthChecksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHealthChecksWithContext indicates an expected call of ListHealthChecksWithContext
func (mr *MockRoute53APIMockRecorder) ListHealthChecksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksWithContext), varargs...)
}

// ListHealthChecksRequest mocks base method
func (m *MockRoute53API) ListHealthChecksRequest(arg0 *route53.ListHealthChecksInput) (*request.Request, *route53.ListHealthChecksOutput) {
	ret := m.ctrl.Call(m, "ListHealthChecksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListHealthChecksOutput)
	return ret0, ret1
}

// ListHealthChecksRequest indicates an expected call of ListHealthChecksRequest
func (mr *MockRoute53APIMockRecorder) ListHealthChecksRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksRequest), arg0)
}

// ListHealthChecksPages mocks base method
func (m *MockRoute53API) ListHealthChecksPages(arg0 *route53.ListHealthChecksInput, arg1 func(*route53.ListHealthChecksOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListHealthChecksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListHealthChecksPages indicates an expected call of ListHealthChecksPages
func (mr *MockRoute53APIMockRecorder) ListHealthChecksPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksPages", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksPages), arg0, arg1)
}

// ListHealthChecksPagesWithContext mocks base method
func (m *MockRoute53API) ListHealthChecksPagesWithContext(arg0 aws.Context, arg1 *route53.ListHealthChecksInput, arg2 func(*route53.ListHealthChecksOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHealthChecksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListHealthChecksPagesWithContext indicates an expected call of ListHealthChecksPagesWithContext
func (mr *MockRoute53APIMockRecorder) ListHealthChecksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksPagesWithContext), varargs...)
}

// ListHostedZones mocks base method
func (m *MockRoute53API) ListHostedZones(arg0 *route53.ListHostedZonesInput) (*route53.ListHostedZonesOutput, error) {
	ret := m.ctrl.Call(m, "ListHostedZones", arg0)
	ret0, _ := ret[0].(*route53.ListHostedZonesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHostedZones indicates an expected call of ListHostedZones
func (mr *MockRoute53APIMockRecorder) ListHostedZones(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZones", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZones), arg0)
}

// ListHostedZonesWithContext mocks base method
func (m *MockRoute53API) ListHostedZonesWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesInput, arg2 ...request.Option) (*route53.ListHostedZonesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHostedZonesWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListHostedZonesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHostedZonesWithContext indicates an expected call of ListHostedZonesWithContext
func (mr *MockRoute53APIMockRecorder) ListHostedZonesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesWithContext), varargs...)
}

// ListHostedZonesRequest mocks base method
func (m *MockRoute53API) ListHostedZonesRequest(arg0 *route53.ListHostedZonesInput) (*request.Request, *route53.ListHostedZonesOutput) {
	ret := m.ctrl.Call(m, "ListHostedZonesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListHostedZonesOutput)
	return ret0, ret1
}

// ListHostedZonesRequest indicates an expected call of ListHostedZonesRequest
func (mr *MockRoute53APIMockRecorder) ListHostedZonesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesRequest), arg0)
}

// ListHostedZonesPages mocks base method
func (m *MockRoute53API) ListHostedZonesPages(arg0 *route53.ListHostedZonesInput, arg1 func(*route53.ListHostedZonesOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListHostedZonesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListHostedZonesPages indicates an expected call of ListHostedZonesPages
func (mr *MockRoute53APIMockRecorder) ListHostedZonesPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesPages", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesPages), arg0, arg1)
}

// ListHostedZonesPagesWithContext mocks base method
func (m *MockRoute53API) ListHostedZonesPagesWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesInput, arg2 func(*route53.ListHostedZonesOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHostedZonesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListHostedZonesPagesWithContext indicates an expected call of ListHostedZonesPagesWithContext
func (mr *MockRoute53APIMockRecorder) ListHostedZonesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesPagesWithContext), varargs...)
}

// ListHostedZonesByName mocks base method
func (m *MockRoute53API) ListHostedZonesByName(arg0 *route53.ListHostedZonesByNameInput) (*route53.ListHostedZonesByNameOutput, error) {
	ret := m.ctrl.Call(m, "ListHostedZonesByName", arg0)
	ret0, _ := ret[0].(*route53.ListHostedZonesByNameOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHostedZonesByName indicates an expected call of ListHostedZonesByName
func (mr *MockRoute53APIMockRecorder) ListHostedZonesByName(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByName", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByName), arg0)
}

// ListHostedZonesByNameWithContext mocks base method
func (m *MockRoute53API) ListHostedZonesByNameWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesByNameInput, arg2 ...request.Option) (*route53.ListHostedZonesByNameOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHostedZonesByNameWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListHostedZonesByNameOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHostedZonesByNameWithContext indicates an expected call of ListHostedZonesByNameWithContext
func (mr *MockRoute53APIMockRecorder) ListHostedZonesByNameWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByNameWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByNameWithContext), varargs...)
}

// ListHostedZonesByNameRequest mocks base method
func (m *MockRoute53API) ListHostedZonesByNameRequest(arg0 *route53.ListHostedZonesByNameInput) (*request.Request, *route53.ListHostedZonesByNameOutput) {
	ret := m.ctrl.Call(m, "ListHostedZonesByNameRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListHostedZonesByNameOutput)
	return ret0, ret1
}

// ListHostedZonesByNameRequest indicates an expected call of ListHostedZonesByNameRequest
func (mr *MockRoute53APIMockRecorder) ListHostedZonesByNameRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByNameRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByNameRequest), arg0)
}

// ListQueryLoggingConfigs mocks base method
func (m *MockRoute53API) ListQueryLoggingConfigs(arg0 *route53.ListQueryLoggingConfigsInput) (*route53.ListQueryLoggingConfigsOutput, error) {
	ret := m.ctrl.Call(m, "ListQueryLoggingConfigs", arg0)
	ret0, _ := ret[0].(*route53.ListQueryLoggingConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueryLoggingConfigs indicates an expected call of ListQueryLoggingConfigs
func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigs(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigs", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigs), arg0)
}

// ListQueryLoggingConfigsWithContext mocks base method
func (m *MockRoute53API) ListQueryLoggingConfigsWithContext(arg0 aws.Context, arg1 *route53.ListQueryLoggingConfigsInput, arg2 ...request.Option) (*route53.ListQueryLoggingConfigsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListQueryLoggingConfigsWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListQueryLoggingConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueryLoggingConfigsWithContext indicates an expected call of ListQueryLoggingConfigsWithContext
func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigsWithContext), varargs...)
}

// ListQueryLoggingConfigsRequest mocks base method
func (m *MockRoute53API) ListQueryLoggingConfigsRequest(arg0 *route53.ListQueryLoggingConfigsInput) (*request.Request, *route53.ListQueryLoggingConfigsOutput) {
	ret := m.ctrl.Call(m, "ListQueryLoggingConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListQueryLoggingConfigsOutput)
	return ret0, ret1
}

// ListQueryLoggingConfigsRequest indicates an expected call of ListQueryLoggingConfigsRequest
func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigsRequest), arg0)
}

// ListResourceRecordSets mocks base method
func (m *MockRoute53API) ListResourceRecordSets(arg0 *route53.ListResourceRecordSetsInput) (*route53.ListResourceRecordSetsOutput, error) {
	ret := m.ctrl.Call(m, "ListResourceRecordSets", arg0)
	ret0, _ := ret[0].(*route53.ListResourceRecordSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListResourceRecordSets indicates an expected call of ListResourceRecordSets
func (mr *MockRoute53APIMockRecorder) ListResourceRecordSets(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSets", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSets), arg0)
}

// ListResourceRecordSetsWithContext mocks base method
func (m *MockRoute53API) ListResourceRecordSetsWithContext(arg0 aws.Context, arg1 *route53.ListResourceRecordSetsInput, arg2 ...request.Option) (*route53.ListResourceRecordSetsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListResourceRecordSetsWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListResourceRecordSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListResourceRecordSetsWithContext indicates an expected call of ListResourceRecordSetsWithContext
func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsWithContext), varargs...)
}

// ListResourceRecordSetsRequest mocks base method
func (m *MockRoute53API) ListResourceRecordSetsRequest(arg0 *route53.ListResourceRecordSetsInput) (*request.Request, *route53.ListResourceRecordSetsOutput) {
	ret := m.ctrl.Call(m, "ListResourceRecordSetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListResourceRecordSetsOutput)
	return ret0, ret1
}

// ListResourceRecordSetsRequest indicates an expected call of ListResourceRecordSetsRequest
func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsRequest), arg0)
}

// ListResourceRecordSetsPages mocks base method
func (m *MockRoute53API) ListResourceRecordSetsPages(arg0 *route53.ListResourceRecordSetsInput, arg1 func(*route53.ListResourceRecordSetsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListResourceRecordSetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListResourceRecordSetsPages indicates an expected call of ListResourceRecordSetsPages
func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsPages", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsPages), arg0, arg1)
}

// ListResourceRecordSetsPagesWithContext mocks base method
func (m *MockRoute53API) ListResourceRecordSetsPagesWithContext(arg0 aws.Context, arg1 *route53.ListResourceRecordSetsInput, arg2 func(*route53.ListResourceRecordSetsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListResourceRecordSetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListResourceRecordSetsPagesWithContext indicates an expected call of ListResourceRecordSetsPagesWithContext
func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsPagesWithContext), varargs...)
}

// ListReusableDelegationSets mocks base method
func (m *MockRoute53API) ListReusableDelegationSets(arg0 *route53.ListReusableDelegationSetsInput) (*route53.ListReusableDelegationSetsOutput, error) {
	ret := m.ctrl.Call(m, "ListReusableDelegationSets", arg0)
	ret0, _ := ret[0].(*route53.ListReusableDelegationSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListReusableDelegationSets indicates an expected call of ListReusableDelegationSets
func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSets(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSets", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSets), arg0)
}

// ListReusableDelegationSetsWithContext mocks base method
func (m *MockRoute53API) ListReusableDelegationSetsWithContext(arg0 aws.Context, arg1 *route53.ListReusableDelegationSetsInput, arg2 ...request.Option) (*route53.ListReusableDelegationSetsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListReusableDelegationSetsWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListReusableDelegationSetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListReusableDelegationSetsWithContext indicates an expected call of ListReusableDelegationSetsWithContext
func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSetsWithContext), varargs...)
}

// ListReusableDelegationSetsRequest mocks base method
func (m *MockRoute53API) ListReusableDelegationSetsRequest(arg0 *route53.ListReusableDelegationSetsInput) (*request.Request, *route53.ListReusableDelegationSetsOutput) {
	ret := m.ctrl.Call(m, "ListReusableDelegationSetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListReusableDelegationSetsOutput)
	return ret0, ret1
}

// ListReusableDelegationSetsRequest indicates an expected call of ListReusableDelegationSetsRequest
func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSetsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSetsRequest), arg0)
}

// ListTagsForResource mocks base method
func (m *MockRoute53API) ListTagsForResource(arg0 *route53.ListTagsForResourceInput) (*route53.ListTagsForResourceOutput, error) {
	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
	ret0, _ := ret[0].(*route53.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResource indicates an expected call of ListTagsForResource
func (mr *MockRoute53APIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResource), arg0)
}

// ListTagsForResourceWithContext mocks base method
func (m *MockRoute53API) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *route53.ListTagsForResourceInput, arg2 ...request.Option) (*route53.ListTagsForResourceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext
func (mr *MockRoute53APIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourceWithContext), varargs...)
}

// ListTagsForResourceRequest mocks base method
func (m *MockRoute53API) ListTagsForResourceRequest(arg0 *route53.ListTagsForResourceInput) (*request.Request, *route53.ListTagsForResourceOutput) {
	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListTagsForResourceOutput)
	return ret0, ret1
}

// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest
func (mr *MockRoute53APIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourceRequest), arg0)
}

// ListTagsForResources mocks base method
func (m *MockRoute53API) ListTagsForResources(arg0 *route53.ListTagsForResourcesInput) (*route53.ListTagsForResourcesOutput, error) {
	ret := m.ctrl.Call(m, "ListTagsForResources", arg0)
	ret0, _ := ret[0].(*route53.ListTagsForResourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResources indicates an expected call of ListTagsForResources
func (mr *MockRoute53APIMockRecorder) ListTagsForResources(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResources", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResources), arg0)
}

// ListTagsForResourcesWithContext mocks base method
func (m *MockRoute53API) ListTagsForResourcesWithContext(arg0 aws.Context, arg1 *route53.ListTagsForResourcesInput, arg2 ...request.Option) (*route53.ListTagsForResourcesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsForResourcesWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListTagsForResourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResourcesWithContext indicates an expected call of ListTagsForResourcesWithContext
func (mr *MockRoute53APIMockRecorder) ListTagsForResourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourcesWithContext), varargs...)
}

// ListTagsForResourcesRequest mocks base method
func (m *MockRoute53API) ListTagsForResourcesRequest(arg0 *route53.ListTagsForResourcesInput) (*request.Request, *route53.ListTagsForResourcesOutput) {
	ret := m.ctrl.Call(m, "ListTagsForResourcesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListTagsForResourcesOutput)
	return ret0, ret1
}

// ListTagsForResourcesRequest indicates an expected call of ListTagsForResourcesRequest
func (mr *MockRoute53APIMockRecorder) ListTagsForResourcesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourcesRequest), arg0)
}

// ListTrafficPolicies mocks base method
func (m *MockRoute53API) ListTrafficPolicies(arg0 *route53.ListTrafficPoliciesInput) (*route53.ListTrafficPoliciesOutput, error) {
	ret := m.ctrl.Call(m, "ListTrafficPolicies", arg0)
	ret0, _ := ret[0].(*route53.ListTrafficPoliciesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicies indicates an expected call of ListTrafficPolicies
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicies(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicies", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicies), arg0)
}

// ListTrafficPoliciesWithContext mocks base method
func (m *MockRoute53API) ListTrafficPoliciesWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPoliciesInput, arg2 ...request.Option) (*route53.ListTrafficPoliciesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrafficPoliciesWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListTrafficPoliciesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPoliciesWithContext indicates an expected call of ListTrafficPoliciesWithContext
func (mr *MockRoute53APIMockRecorder) ListTrafficPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPoliciesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPoliciesWithContext), varargs...)
}

// ListTrafficPoliciesRequest mocks base method
func (m *MockRoute53API) ListTrafficPoliciesRequest(arg0 *route53.ListTrafficPoliciesInput) (*request.Request, *route53.ListTrafficPoliciesOutput) {
	ret := m.ctrl.Call(m, "ListTrafficPoliciesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListTrafficPoliciesOutput)
	return ret0, ret1
}

// ListTrafficPoliciesRequest indicates an expected call of ListTrafficPoliciesRequest
func (mr *MockRoute53APIMockRecorder) ListTrafficPoliciesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPoliciesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPoliciesRequest), arg0)
}

// ListTrafficPolicyInstances mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstances(arg0 *route53.ListTrafficPolicyInstancesInput) (*route53.ListTrafficPolicyInstancesOutput, error) {
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstances", arg0)
	ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicyInstances indicates an expected call of ListTrafficPolicyInstances
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstances(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstances", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstances), arg0)
}

// ListTrafficPolicyInstancesWithContext mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstancesWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicyInstancesWithContext indicates an expected call of ListTrafficPolicyInstancesWithContext
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesWithContext), varargs...)
}

// ListTrafficPolicyInstancesRequest mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstancesRequest(arg0 *route53.ListTrafficPolicyInstancesInput) (*request.Request, *route53.ListTrafficPolicyInstancesOutput) {
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesOutput)
	return ret0, ret1
}

// ListTrafficPolicyInstancesRequest indicates an expected call of ListTrafficPolicyInstancesRequest
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesRequest), arg0)
}

// ListTrafficPolicyInstancesByHostedZone mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZone(arg0 *route53.ListTrafficPolicyInstancesByHostedZoneInput) (*route53.ListTrafficPolicyInstancesByHostedZoneOutput, error) {
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZone", arg0)
	ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicyInstancesByHostedZone indicates an expected call of ListTrafficPolicyInstancesByHostedZone
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZone(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZone", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZone), arg0)
}

// ListTrafficPolicyInstancesByHostedZoneWithContext mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZoneWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesByHostedZoneInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesByHostedZoneOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZoneWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicyInstancesByHostedZoneWithContext indicates an expected call of ListTrafficPolicyInstancesByHostedZoneWithContext
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZoneWithContext), varargs...)
}

// ListTrafficPolicyInstancesByHostedZoneRequest mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZoneRequest(arg0 *route53.ListTrafficPolicyInstancesByHostedZoneInput) (*request.Request, *route53.ListTrafficPolicyInstancesByHostedZoneOutput) {
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZoneRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput)
	return ret0, ret1
}

// ListTrafficPolicyInstancesByHostedZoneRequest indicates an expected call of ListTrafficPolicyInstancesByHostedZoneRequest
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZoneRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZoneRequest), arg0)
}

// ListTrafficPolicyInstancesByPolicy mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicy(arg0 *route53.ListTrafficPolicyInstancesByPolicyInput) (*route53.ListTrafficPolicyInstancesByPolicyOutput, error) {
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicy", arg0)
	ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicyInstancesByPolicy indicates an expected call of ListTrafficPolicyInstancesByPolicy
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicy(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicy", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicy), arg0)
}

// ListTrafficPolicyInstancesByPolicyWithContext mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicyWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesByPolicyInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesByPolicyOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicyInstancesByPolicyWithContext indicates an expected call of ListTrafficPolicyInstancesByPolicyWithContext
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicyWithContext), varargs...)
}

// ListTrafficPolicyInstancesByPolicyRequest mocks base method
func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicyRequest(arg0 *route53.ListTrafficPolicyInstancesByPolicyInput) (*request.Request, *route53.ListTrafficPolicyInstancesByPolicyOutput) {
	ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesByPolicyOutput)
	return ret0, ret1
}

// ListTrafficPolicyInstancesByPolicyRequest indicates an expected call of ListTrafficPolicyInstancesByPolicyRequest
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicyRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicyRequest), arg0)
}

// ListTrafficPolicyVersions mocks base method
func (m *MockRoute53API) ListTrafficPolicyVersions(arg0 *route53.ListTrafficPolicyVersionsInput) (*route53.ListTrafficPolicyVersionsOutput, error) {
	ret := m.ctrl.Call(m, "ListTrafficPolicyVersions", arg0)
	ret0, _ := ret[0].(*route53.ListTrafficPolicyVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicyVersions indicates an expected call of ListTrafficPolicyVersions
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersions", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersions), arg0)
}

// ListTrafficPolicyVersionsWithContext mocks base method
func (m *MockRoute53API) ListTrafficPolicyVersionsWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyVersionsInput, arg2 ...request.Option) (*route53.ListTrafficPolicyVersionsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrafficPolicyVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListTrafficPolicyVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrafficPolicyVersionsWithContext indicates an expected call of ListTrafficPolicyVersionsWithContext
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersionsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersionsWithContext), varargs...)
}

// ListTrafficPolicyVersionsRequest mocks base method
func (m *MockRoute53API) ListTrafficPolicyVersionsRequest(arg0 *route53.ListTrafficPolicyVersionsInput) (*request.Request, *route53.ListTrafficPolicyVersionsOutput) {
	ret := m.ctrl.Call(m, "ListTrafficPolicyVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListTrafficPolicyVersionsOutput)
	return ret0, ret1
}

// ListTrafficPolicyVersionsRequest indicates an expected call of ListTrafficPolicyVersionsRequest
func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersionsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersionsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersionsRequest), arg0)
}

// ListVPCAssociationAuthorizations mocks base method
func (m *MockRoute53API) ListVPCAssociationAuthorizations(arg0 *route53.ListVPCAssociationAuthorizationsInput) (*route53.ListVPCAssociationAuthorizationsOutput, error) {
	ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizations", arg0)
	ret0, _ := ret[0].(*route53.ListVPCAssociationAuthorizationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVPCAssociationAuthorizations indicates an expected call of ListVPCAssociationAuthorizations
func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizations(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizations", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizations), arg0)
}

// ListVPCAssociationAuthorizationsWithContext mocks base method
func (m *MockRoute53API) ListVPCAssociationAuthorizationsWithContext(arg0 aws.Context, arg1 *route53.ListVPCAssociationAuthorizationsInput, arg2 ...request.Option) (*route53.ListVPCAssociationAuthorizationsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizationsWithContext", varargs...)
	ret0, _ := ret[0].(*route53.ListVPCAssociationAuthorizationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListVPCAssociationAuthorizationsWithContext indicates an expected call of ListVPCAssociationAuthorizationsWithContext
func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizationsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizationsWithContext), varargs...)
}

// ListVPCAssociationAuthorizationsRequest mocks base method
func (m *MockRoute53API) ListVPCAssociationAuthorizationsRequest(arg0 *route53.ListVPCAssociationAuthorizationsInput) (*request.Request, *route53.ListVPCAssociationAuthorizationsOutput) {
	ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.ListVPCAssociationAuthorizationsOutput)
	return ret0, ret1
}

// ListVPCAssociationAuthorizationsRequest indicates an expected call of ListVPCAssociationAuthorizationsRequest
func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizationsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizationsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizationsRequest), arg0)
}

// TestDNSAnswer mocks base method
func (m *MockRoute53API) TestDNSAnswer(arg0 *route53.TestDNSAnswerInput) (*route53.TestDNSAnswerOutput, error) {
	ret := m.ctrl.Call(m, "TestDNSAnswer", arg0)
	ret0, _ := ret[0].(*route53.TestDNSAnswerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TestDNSAnswer indicates an expected call of TestDNSAnswer
func (mr *MockRoute53APIMockRecorder) TestDNSAnswer(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswer", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswer), arg0)
}

// TestDNSAnswerWithContext mocks base method
func (m *MockRoute53API) TestDNSAnswerWithContext(arg0 aws.Context, arg1 *route53.TestDNSAnswerInput, arg2 ...request.Option) (*route53.TestDNSAnswerOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TestDNSAnswerWithContext", varargs...)
	ret0, _ := ret[0].(*route53.TestDNSAnswerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TestDNSAnswerWithContext indicates an expected call of TestDNSAnswerWithContext
func (mr *MockRoute53APIMockRecorder) TestDNSAnswerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswerWithContext", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswerWithContext), varargs...)
}

// TestDNSAnswerRequest mocks base method
func (m *MockRoute53API) TestDNSAnswerRequest(arg0 *route53.TestDNSAnswerInput) (*request.Request, *route53.TestDNSAnswerOutput) {
	ret := m.ctrl.Call(m, "TestDNSAnswerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.TestDNSAnswerOutput)
	return ret0, ret1
}

// TestDNSAnswerRequest indicates an expected call of TestDNSAnswerRequest
func (mr *MockRoute53APIMockRecorder) TestDNSAnswerRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswerRequest", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswerRequest), arg0)
}

// UpdateHealthCheck mocks base method
func (m *MockRoute53API) UpdateHealthCheck(arg0 *route53.UpdateHealthCheckInput) (*route53.UpdateHealthCheckOutput, error) {
	ret := m.ctrl.Call(m, "UpdateHealthCheck", arg0)
	ret0, _ := ret[0].(*route53.UpdateHealthCheckOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateHealthCheck indicates an expected call of UpdateHealthCheck
func (mr *MockRoute53APIMockRecorder) UpdateHealthCheck(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheck), arg0)
}

// UpdateHealthCheckWithContext mocks base method
func (m *MockRoute53API) UpdateHealthCheckWithContext(arg0 aws.Context, arg1 *route53.UpdateHealthCheckInput, arg2 ...request.Option) (*route53.UpdateHealthCheckOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateHealthCheckWithContext", varargs...)
	ret0, _ := ret[0].(*route53.UpdateHealthCheckOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateHealthCheckWithContext indicates an expected call of UpdateHealthCheckWithContext
func (mr *MockRoute53APIMockRecorder) UpdateHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheckWithContext), varargs...)
}

// UpdateHealthCheckRequest mocks base method
func (m *MockRoute53API) UpdateHealthCheckRequest(arg0 *route53.UpdateHealthCheckInput) (*request.Request, *route53.UpdateHealthCheckOutput) {
	ret := m.ctrl.Call(m, "UpdateHealthCheckRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.UpdateHealthCheckOutput)
	return ret0, ret1
}

// UpdateHealthCheckRequest indicates an expected call of UpdateHealthCheckRequest
func (mr *MockRoute53APIMockRecorder) UpdateHealthCheckRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheckRequest), arg0)
}

// UpdateHostedZoneComment mocks base method
func (m *MockRoute53API) UpdateHostedZoneComment(arg0 *route53.UpdateHostedZoneCommentInput) (*route53.UpdateHostedZoneCommentOutput, error) {
	ret := m.ctrl.Call(m, "UpdateHostedZoneComment", arg0)
	ret0, _ := ret[0].(*route53.UpdateHostedZoneCommentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateHostedZoneComment indicates an expected call of UpdateHostedZoneComment
func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneComment(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneComment", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneComment), arg0)
}

// UpdateHostedZoneCommentWithContext mocks base method
func (m *MockRoute53API) UpdateHostedZoneCommentWithContext(arg0 aws.Context, arg1 *route53.UpdateHostedZoneCommentInput, arg2 ...request.Option) (*route53.UpdateHostedZoneCommentOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateHostedZoneCommentWithContext", varargs...)
	ret0, _ := ret[0].(*route53.UpdateHostedZoneCommentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateHostedZoneCommentWithContext indicates an expected call of UpdateHostedZoneCommentWithContext
func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneCommentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneCommentWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneCommentWithContext), varargs...)
}

// UpdateHostedZoneCommentRequest mocks base method
func (m *MockRoute53API) UpdateHostedZoneCommentRequest(arg0 *route53.UpdateHostedZoneCommentInput) (*request.Request, *route53.UpdateHostedZoneCommentOutput) {
	ret := m.ctrl.Call(m, "UpdateHostedZoneCommentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.UpdateHostedZoneCommentOutput)
	return ret0, ret1
}

// UpdateHostedZoneCommentRequest indicates an expected call of UpdateHostedZoneCommentRequest
func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneCommentRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneCommentRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneCommentRequest), arg0)
}

// UpdateTrafficPolicyComment mocks base method
func (m *MockRoute53API) UpdateTrafficPolicyComment(arg0 *route53.UpdateTrafficPolicyCommentInput) (*route53.UpdateTrafficPolicyCommentOutput, error) {
	ret := m.ctrl.Call(m, "UpdateTrafficPolicyComment", arg0)
	ret0, _ := ret[0].(*route53.UpdateTrafficPolicyCommentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrafficPolicyComment indicates an expected call of UpdateTrafficPolicyComment
func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyComment(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyComment", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyComment), arg0)
}

// UpdateTrafficPolicyCommentWithContext mocks base method
func (m *MockRoute53API) UpdateTrafficPolicyCommentWithContext(arg0 aws.Context, arg1 *route53.UpdateTrafficPolicyCommentInput, arg2 ...request.Option) (*route53.UpdateTrafficPolicyCommentOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTrafficPolicyCommentWithContext", varargs...)
	ret0, _ := ret[0].(*route53.UpdateTrafficPolicyCommentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrafficPolicyCommentWithContext indicates an expected call of UpdateTrafficPolicyCommentWithContext
func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyCommentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyCommentWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyCommentWithContext), varargs...)
}

// UpdateTrafficPolicyCommentRequest mocks base method
func (m *MockRoute53API) UpdateTrafficPolicyCommentRequest(arg0 *route53.UpdateTrafficPolicyCommentInput) (*request.Request, *route53.UpdateTrafficPolicyCommentOutput) {
	ret := m.ctrl.Call(m, "UpdateTrafficPolicyCommentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.UpdateTrafficPolicyCommentOutput)
	return ret0, ret1
}

// UpdateTrafficPolicyCommentRequest indicates an expected call of UpdateTrafficPolicyCommentRequest
func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyCommentRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyCommentRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyCommentRequest), arg0)
}

// UpdateTrafficPolicyInstance mocks base method
func (m *MockRoute53API) UpdateTrafficPolicyInstance(arg0 *route53.UpdateTrafficPolicyInstanceInput) (*route53.UpdateTrafficPolicyInstanceOutput, error) {
	ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstance", arg0)
	ret0, _ := ret[0].(*route53.UpdateTrafficPolicyInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrafficPolicyInstance indicates an expected call of UpdateTrafficPolicyInstance
func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstance(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstance), arg0)
}

// UpdateTrafficPolicyInstanceWithContext mocks base method
func (m *MockRoute53API) UpdateTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.UpdateTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.UpdateTrafficPolicyInstanceOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*route53.UpdateTrafficPolicyInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTrafficPolicyInstanceWithContext indicates an expected call of UpdateTrafficPolicyInstanceWithContext
func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstanceWithContext), varargs...)
}

// UpdateTrafficPolicyInstanceRequest mocks base method
func (m *MockRoute53API) UpdateTrafficPolicyInstanceRequest(arg0 *route53.UpdateTrafficPolicyInstanceInput) (*request.Request, *route53.UpdateTrafficPolicyInstanceOutput) {
	ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*route53.UpdateTrafficPolicyInstanceOutput)
	return ret0, ret1
}

// UpdateTrafficPolicyInstanceRequest indicates an expected call of UpdateTrafficPolicyInstanceRequest
func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstanceRequest), arg0)
}

// WaitUntilResourceRecordSetsChanged mocks base method
func (m *MockRoute53API) WaitUntilResourceRecordSetsChanged(arg0 *route53.GetChangeInput) error {
	ret := m.ctrl.Call(m, "WaitUntilResourceRecordSetsChanged", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilResourceRecordSetsChanged indicates an expected call of WaitUntilResourceRecordSetsChanged
func (mr *MockRoute53APIMockRecorder) WaitUntilResourceRecordSetsChanged(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilResourceRecordSetsChanged", reflect.TypeOf((*MockRoute53API)(nil).WaitUntilResourceRecordSetsChanged), arg0)
}

// WaitUntilResourceRecordSetsChangedWithContext mocks base method
func (m *MockRoute53API) WaitUntilResourceRecordSetsChangedWithContext(arg0 aws.Context, arg1 *route53.GetChangeInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilResourceRecordSetsChangedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilResourceRecordSetsChangedWithContext indicates an expected call of WaitUntilResourceRecordSetsChangedWithContext
func (mr *MockRoute53APIMockRecorder) WaitUntilResourceRecordSetsChangedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilResourceRecordSetsChangedWithContext", reflect.TypeOf((*MockRoute53API)(nil).WaitUntilResourceRecordSetsChangedWithContext), varargs...)
}