driftctl/mocks/Route53Client.go

// Code generated by mockery v1.0.0. DO NOT EDIT.

package mocks

import (
	context "context"

	mock "github.com/stretchr/testify/mock"

	request "github.com/aws/aws-sdk-go/aws/request"

	route53 "github.com/aws/aws-sdk-go/service/route53"
)

// Route53Client is an autogenerated mock type for the Route53Client type
type Route53Client struct {
	mock.Mock
}

// AssociateVPCWithHostedZone provides a mock function with given fields: _a0
func (_m *Route53Client) AssociateVPCWithHostedZone(_a0 *route53.AssociateVPCWithHostedZoneInput) (*route53.AssociateVPCWithHostedZoneOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.AssociateVPCWithHostedZoneOutput
	if rf, ok := ret.Get(0).(func(*route53.AssociateVPCWithHostedZoneInput) *route53.AssociateVPCWithHostedZoneOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.AssociateVPCWithHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.AssociateVPCWithHostedZoneInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AssociateVPCWithHostedZoneRequest provides a mock function with given fields: _a0
func (_m *Route53Client) AssociateVPCWithHostedZoneRequest(_a0 *route53.AssociateVPCWithHostedZoneInput) (*request.Request, *route53.AssociateVPCWithHostedZoneOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.AssociateVPCWithHostedZoneInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.AssociateVPCWithHostedZoneOutput
	if rf, ok := ret.Get(1).(func(*route53.AssociateVPCWithHostedZoneInput) *route53.AssociateVPCWithHostedZoneOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.AssociateVPCWithHostedZoneOutput)
		}
	}

	return r0, r1
}

// AssociateVPCWithHostedZoneWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) AssociateVPCWithHostedZoneWithContext(_a0 context.Context, _a1 *route53.AssociateVPCWithHostedZoneInput, _a2 ...request.Option) (*route53.AssociateVPCWithHostedZoneOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.AssociateVPCWithHostedZoneOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.AssociateVPCWithHostedZoneInput, ...request.Option) *route53.AssociateVPCWithHostedZoneOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.AssociateVPCWithHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.AssociateVPCWithHostedZoneInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChangeResourceRecordSets provides a mock function with given fields: _a0
func (_m *Route53Client) ChangeResourceRecordSets(_a0 *route53.ChangeResourceRecordSetsInput) (*route53.ChangeResourceRecordSetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ChangeResourceRecordSetsOutput
	if rf, ok := ret.Get(0).(func(*route53.ChangeResourceRecordSetsInput) *route53.ChangeResourceRecordSetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ChangeResourceRecordSetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ChangeResourceRecordSetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChangeResourceRecordSetsRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ChangeResourceRecordSetsRequest(_a0 *route53.ChangeResourceRecordSetsInput) (*request.Request, *route53.ChangeResourceRecordSetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ChangeResourceRecordSetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ChangeResourceRecordSetsOutput
	if rf, ok := ret.Get(1).(func(*route53.ChangeResourceRecordSetsInput) *route53.ChangeResourceRecordSetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ChangeResourceRecordSetsOutput)
		}
	}

	return r0, r1
}

// ChangeResourceRecordSetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ChangeResourceRecordSetsWithContext(_a0 context.Context, _a1 *route53.ChangeResourceRecordSetsInput, _a2 ...request.Option) (*route53.ChangeResourceRecordSetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ChangeResourceRecordSetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ChangeResourceRecordSetsInput, ...request.Option) *route53.ChangeResourceRecordSetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ChangeResourceRecordSetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ChangeResourceRecordSetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChangeTagsForResource provides a mock function with given fields: _a0
func (_m *Route53Client) ChangeTagsForResource(_a0 *route53.ChangeTagsForResourceInput) (*route53.ChangeTagsForResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ChangeTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(*route53.ChangeTagsForResourceInput) *route53.ChangeTagsForResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ChangeTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ChangeTagsForResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChangeTagsForResourceRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ChangeTagsForResourceRequest(_a0 *route53.ChangeTagsForResourceInput) (*request.Request, *route53.ChangeTagsForResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ChangeTagsForResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ChangeTagsForResourceOutput
	if rf, ok := ret.Get(1).(func(*route53.ChangeTagsForResourceInput) *route53.ChangeTagsForResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ChangeTagsForResourceOutput)
		}
	}

	return r0, r1
}

// ChangeTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ChangeTagsForResourceWithContext(_a0 context.Context, _a1 *route53.ChangeTagsForResourceInput, _a2 ...request.Option) (*route53.ChangeTagsForResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ChangeTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ChangeTagsForResourceInput, ...request.Option) *route53.ChangeTagsForResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ChangeTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ChangeTagsForResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateHealthCheck provides a mock function with given fields: _a0
func (_m *Route53Client) CreateHealthCheck(_a0 *route53.CreateHealthCheckInput) (*route53.CreateHealthCheckOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.CreateHealthCheckOutput
	if rf, ok := ret.Get(0).(func(*route53.CreateHealthCheckInput) *route53.CreateHealthCheckOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateHealthCheckOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.CreateHealthCheckInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateHealthCheckRequest provides a mock function with given fields: _a0
func (_m *Route53Client) CreateHealthCheckRequest(_a0 *route53.CreateHealthCheckInput) (*request.Request, *route53.CreateHealthCheckOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.CreateHealthCheckInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.CreateHealthCheckOutput
	if rf, ok := ret.Get(1).(func(*route53.CreateHealthCheckInput) *route53.CreateHealthCheckOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.CreateHealthCheckOutput)
		}
	}

	return r0, r1
}

// CreateHealthCheckWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) CreateHealthCheckWithContext(_a0 context.Context, _a1 *route53.CreateHealthCheckInput, _a2 ...request.Option) (*route53.CreateHealthCheckOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.CreateHealthCheckOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.CreateHealthCheckInput, ...request.Option) *route53.CreateHealthCheckOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateHealthCheckOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.CreateHealthCheckInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateHostedZone provides a mock function with given fields: _a0
func (_m *Route53Client) CreateHostedZone(_a0 *route53.CreateHostedZoneInput) (*route53.CreateHostedZoneOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.CreateHostedZoneOutput
	if rf, ok := ret.Get(0).(func(*route53.CreateHostedZoneInput) *route53.CreateHostedZoneOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.CreateHostedZoneInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateHostedZoneRequest provides a mock function with given fields: _a0
func (_m *Route53Client) CreateHostedZoneRequest(_a0 *route53.CreateHostedZoneInput) (*request.Request, *route53.CreateHostedZoneOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.CreateHostedZoneInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.CreateHostedZoneOutput
	if rf, ok := ret.Get(1).(func(*route53.CreateHostedZoneInput) *route53.CreateHostedZoneOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.CreateHostedZoneOutput)
		}
	}

	return r0, r1
}

// CreateHostedZoneWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) CreateHostedZoneWithContext(_a0 context.Context, _a1 *route53.CreateHostedZoneInput, _a2 ...request.Option) (*route53.CreateHostedZoneOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.CreateHostedZoneOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.CreateHostedZoneInput, ...request.Option) *route53.CreateHostedZoneOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.CreateHostedZoneInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateQueryLoggingConfig provides a mock function with given fields: _a0
func (_m *Route53Client) CreateQueryLoggingConfig(_a0 *route53.CreateQueryLoggingConfigInput) (*route53.CreateQueryLoggingConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.CreateQueryLoggingConfigOutput
	if rf, ok := ret.Get(0).(func(*route53.CreateQueryLoggingConfigInput) *route53.CreateQueryLoggingConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateQueryLoggingConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.CreateQueryLoggingConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateQueryLoggingConfigRequest provides a mock function with given fields: _a0
func (_m *Route53Client) CreateQueryLoggingConfigRequest(_a0 *route53.CreateQueryLoggingConfigInput) (*request.Request, *route53.CreateQueryLoggingConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.CreateQueryLoggingConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.CreateQueryLoggingConfigOutput
	if rf, ok := ret.Get(1).(func(*route53.CreateQueryLoggingConfigInput) *route53.CreateQueryLoggingConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.CreateQueryLoggingConfigOutput)
		}
	}

	return r0, r1
}

// CreateQueryLoggingConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) CreateQueryLoggingConfigWithContext(_a0 context.Context, _a1 *route53.CreateQueryLoggingConfigInput, _a2 ...request.Option) (*route53.CreateQueryLoggingConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.CreateQueryLoggingConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.CreateQueryLoggingConfigInput, ...request.Option) *route53.CreateQueryLoggingConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateQueryLoggingConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.CreateQueryLoggingConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateReusableDelegationSet provides a mock function with given fields: _a0
func (_m *Route53Client) CreateReusableDelegationSet(_a0 *route53.CreateReusableDelegationSetInput) (*route53.CreateReusableDelegationSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.CreateReusableDelegationSetOutput
	if rf, ok := ret.Get(0).(func(*route53.CreateReusableDelegationSetInput) *route53.CreateReusableDelegationSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateReusableDelegationSetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.CreateReusableDelegationSetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateReusableDelegationSetRequest provides a mock function with given fields: _a0
func (_m *Route53Client) CreateReusableDelegationSetRequest(_a0 *route53.CreateReusableDelegationSetInput) (*request.Request, *route53.CreateReusableDelegationSetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.CreateReusableDelegationSetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.CreateReusableDelegationSetOutput
	if rf, ok := ret.Get(1).(func(*route53.CreateReusableDelegationSetInput) *route53.CreateReusableDelegationSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.CreateReusableDelegationSetOutput)
		}
	}

	return r0, r1
}

// CreateReusableDelegationSetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) CreateReusableDelegationSetWithContext(_a0 context.Context, _a1 *route53.CreateReusableDelegationSetInput, _a2 ...request.Option) (*route53.CreateReusableDelegationSetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.CreateReusableDelegationSetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.CreateReusableDelegationSetInput, ...request.Option) *route53.CreateReusableDelegationSetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateReusableDelegationSetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.CreateReusableDelegationSetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrafficPolicy provides a mock function with given fields: _a0
func (_m *Route53Client) CreateTrafficPolicy(_a0 *route53.CreateTrafficPolicyInput) (*route53.CreateTrafficPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.CreateTrafficPolicyOutput
	if rf, ok := ret.Get(0).(func(*route53.CreateTrafficPolicyInput) *route53.CreateTrafficPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateTrafficPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.CreateTrafficPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrafficPolicyInstance provides a mock function with given fields: _a0
func (_m *Route53Client) CreateTrafficPolicyInstance(_a0 *route53.CreateTrafficPolicyInstanceInput) (*route53.CreateTrafficPolicyInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.CreateTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(0).(func(*route53.CreateTrafficPolicyInstanceInput) *route53.CreateTrafficPolicyInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateTrafficPolicyInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.CreateTrafficPolicyInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrafficPolicyInstanceRequest provides a mock function with given fields: _a0
func (_m *Route53Client) CreateTrafficPolicyInstanceRequest(_a0 *route53.CreateTrafficPolicyInstanceInput) (*request.Request, *route53.CreateTrafficPolicyInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.CreateTrafficPolicyInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.CreateTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(1).(func(*route53.CreateTrafficPolicyInstanceInput) *route53.CreateTrafficPolicyInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.CreateTrafficPolicyInstanceOutput)
		}
	}

	return r0, r1
}

// CreateTrafficPolicyInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) CreateTrafficPolicyInstanceWithContext(_a0 context.Context, _a1 *route53.CreateTrafficPolicyInstanceInput, _a2 ...request.Option) (*route53.CreateTrafficPolicyInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.CreateTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.CreateTrafficPolicyInstanceInput, ...request.Option) *route53.CreateTrafficPolicyInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateTrafficPolicyInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.CreateTrafficPolicyInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrafficPolicyRequest provides a mock function with given fields: _a0
func (_m *Route53Client) CreateTrafficPolicyRequest(_a0 *route53.CreateTrafficPolicyInput) (*request.Request, *route53.CreateTrafficPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.CreateTrafficPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.CreateTrafficPolicyOutput
	if rf, ok := ret.Get(1).(func(*route53.CreateTrafficPolicyInput) *route53.CreateTrafficPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.CreateTrafficPolicyOutput)
		}
	}

	return r0, r1
}

// CreateTrafficPolicyVersion provides a mock function with given fields: _a0
func (_m *Route53Client) CreateTrafficPolicyVersion(_a0 *route53.CreateTrafficPolicyVersionInput) (*route53.CreateTrafficPolicyVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.CreateTrafficPolicyVersionOutput
	if rf, ok := ret.Get(0).(func(*route53.CreateTrafficPolicyVersionInput) *route53.CreateTrafficPolicyVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateTrafficPolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.CreateTrafficPolicyVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrafficPolicyVersionRequest provides a mock function with given fields: _a0
func (_m *Route53Client) CreateTrafficPolicyVersionRequest(_a0 *route53.CreateTrafficPolicyVersionInput) (*request.Request, *route53.CreateTrafficPolicyVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.CreateTrafficPolicyVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.CreateTrafficPolicyVersionOutput
	if rf, ok := ret.Get(1).(func(*route53.CreateTrafficPolicyVersionInput) *route53.CreateTrafficPolicyVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.CreateTrafficPolicyVersionOutput)
		}
	}

	return r0, r1
}

// CreateTrafficPolicyVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) CreateTrafficPolicyVersionWithContext(_a0 context.Context, _a1 *route53.CreateTrafficPolicyVersionInput, _a2 ...request.Option) (*route53.CreateTrafficPolicyVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.CreateTrafficPolicyVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.CreateTrafficPolicyVersionInput, ...request.Option) *route53.CreateTrafficPolicyVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateTrafficPolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.CreateTrafficPolicyVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTrafficPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) CreateTrafficPolicyWithContext(_a0 context.Context, _a1 *route53.CreateTrafficPolicyInput, _a2 ...request.Option) (*route53.CreateTrafficPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.CreateTrafficPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.CreateTrafficPolicyInput, ...request.Option) *route53.CreateTrafficPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateTrafficPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.CreateTrafficPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateVPCAssociationAuthorization provides a mock function with given fields: _a0
func (_m *Route53Client) CreateVPCAssociationAuthorization(_a0 *route53.CreateVPCAssociationAuthorizationInput) (*route53.CreateVPCAssociationAuthorizationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.CreateVPCAssociationAuthorizationOutput
	if rf, ok := ret.Get(0).(func(*route53.CreateVPCAssociationAuthorizationInput) *route53.CreateVPCAssociationAuthorizationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateVPCAssociationAuthorizationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.CreateVPCAssociationAuthorizationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateVPCAssociationAuthorizationRequest provides a mock function with given fields: _a0
func (_m *Route53Client) CreateVPCAssociationAuthorizationRequest(_a0 *route53.CreateVPCAssociationAuthorizationInput) (*request.Request, *route53.CreateVPCAssociationAuthorizationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.CreateVPCAssociationAuthorizationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.CreateVPCAssociationAuthorizationOutput
	if rf, ok := ret.Get(1).(func(*route53.CreateVPCAssociationAuthorizationInput) *route53.CreateVPCAssociationAuthorizationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.CreateVPCAssociationAuthorizationOutput)
		}
	}

	return r0, r1
}

// CreateVPCAssociationAuthorizationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) CreateVPCAssociationAuthorizationWithContext(_a0 context.Context, _a1 *route53.CreateVPCAssociationAuthorizationInput, _a2 ...request.Option) (*route53.CreateVPCAssociationAuthorizationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.CreateVPCAssociationAuthorizationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.CreateVPCAssociationAuthorizationInput, ...request.Option) *route53.CreateVPCAssociationAuthorizationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.CreateVPCAssociationAuthorizationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.CreateVPCAssociationAuthorizationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteHealthCheck provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteHealthCheck(_a0 *route53.DeleteHealthCheckInput) (*route53.DeleteHealthCheckOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.DeleteHealthCheckOutput
	if rf, ok := ret.Get(0).(func(*route53.DeleteHealthCheckInput) *route53.DeleteHealthCheckOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteHealthCheckOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.DeleteHealthCheckInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteHealthCheckRequest provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteHealthCheckRequest(_a0 *route53.DeleteHealthCheckInput) (*request.Request, *route53.DeleteHealthCheckOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.DeleteHealthCheckInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.DeleteHealthCheckOutput
	if rf, ok := ret.Get(1).(func(*route53.DeleteHealthCheckInput) *route53.DeleteHealthCheckOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.DeleteHealthCheckOutput)
		}
	}

	return r0, r1
}

// DeleteHealthCheckWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) DeleteHealthCheckWithContext(_a0 context.Context, _a1 *route53.DeleteHealthCheckInput, _a2 ...request.Option) (*route53.DeleteHealthCheckOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.DeleteHealthCheckOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.DeleteHealthCheckInput, ...request.Option) *route53.DeleteHealthCheckOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteHealthCheckOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.DeleteHealthCheckInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteHostedZone provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteHostedZone(_a0 *route53.DeleteHostedZoneInput) (*route53.DeleteHostedZoneOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.DeleteHostedZoneOutput
	if rf, ok := ret.Get(0).(func(*route53.DeleteHostedZoneInput) *route53.DeleteHostedZoneOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.DeleteHostedZoneInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteHostedZoneRequest provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteHostedZoneRequest(_a0 *route53.DeleteHostedZoneInput) (*request.Request, *route53.DeleteHostedZoneOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.DeleteHostedZoneInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.DeleteHostedZoneOutput
	if rf, ok := ret.Get(1).(func(*route53.DeleteHostedZoneInput) *route53.DeleteHostedZoneOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.DeleteHostedZoneOutput)
		}
	}

	return r0, r1
}

// DeleteHostedZoneWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) DeleteHostedZoneWithContext(_a0 context.Context, _a1 *route53.DeleteHostedZoneInput, _a2 ...request.Option) (*route53.DeleteHostedZoneOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.DeleteHostedZoneOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.DeleteHostedZoneInput, ...request.Option) *route53.DeleteHostedZoneOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.DeleteHostedZoneInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteQueryLoggingConfig provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteQueryLoggingConfig(_a0 *route53.DeleteQueryLoggingConfigInput) (*route53.DeleteQueryLoggingConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.DeleteQueryLoggingConfigOutput
	if rf, ok := ret.Get(0).(func(*route53.DeleteQueryLoggingConfigInput) *route53.DeleteQueryLoggingConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteQueryLoggingConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.DeleteQueryLoggingConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteQueryLoggingConfigRequest provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteQueryLoggingConfigRequest(_a0 *route53.DeleteQueryLoggingConfigInput) (*request.Request, *route53.DeleteQueryLoggingConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.DeleteQueryLoggingConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.DeleteQueryLoggingConfigOutput
	if rf, ok := ret.Get(1).(func(*route53.DeleteQueryLoggingConfigInput) *route53.DeleteQueryLoggingConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.DeleteQueryLoggingConfigOutput)
		}
	}

	return r0, r1
}

// DeleteQueryLoggingConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) DeleteQueryLoggingConfigWithContext(_a0 context.Context, _a1 *route53.DeleteQueryLoggingConfigInput, _a2 ...request.Option) (*route53.DeleteQueryLoggingConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.DeleteQueryLoggingConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.DeleteQueryLoggingConfigInput, ...request.Option) *route53.DeleteQueryLoggingConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteQueryLoggingConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.DeleteQueryLoggingConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteReusableDelegationSet provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteReusableDelegationSet(_a0 *route53.DeleteReusableDelegationSetInput) (*route53.DeleteReusableDelegationSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.DeleteReusableDelegationSetOutput
	if rf, ok := ret.Get(0).(func(*route53.DeleteReusableDelegationSetInput) *route53.DeleteReusableDelegationSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteReusableDelegationSetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.DeleteReusableDelegationSetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteReusableDelegationSetRequest provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteReusableDelegationSetRequest(_a0 *route53.DeleteReusableDelegationSetInput) (*request.Request, *route53.DeleteReusableDelegationSetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.DeleteReusableDelegationSetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.DeleteReusableDelegationSetOutput
	if rf, ok := ret.Get(1).(func(*route53.DeleteReusableDelegationSetInput) *route53.DeleteReusableDelegationSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.DeleteReusableDelegationSetOutput)
		}
	}

	return r0, r1
}

// DeleteReusableDelegationSetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) DeleteReusableDelegationSetWithContext(_a0 context.Context, _a1 *route53.DeleteReusableDelegationSetInput, _a2 ...request.Option) (*route53.DeleteReusableDelegationSetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.DeleteReusableDelegationSetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.DeleteReusableDelegationSetInput, ...request.Option) *route53.DeleteReusableDelegationSetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteReusableDelegationSetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.DeleteReusableDelegationSetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTrafficPolicy provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteTrafficPolicy(_a0 *route53.DeleteTrafficPolicyInput) (*route53.DeleteTrafficPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.DeleteTrafficPolicyOutput
	if rf, ok := ret.Get(0).(func(*route53.DeleteTrafficPolicyInput) *route53.DeleteTrafficPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteTrafficPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.DeleteTrafficPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTrafficPolicyInstance provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteTrafficPolicyInstance(_a0 *route53.DeleteTrafficPolicyInstanceInput) (*route53.DeleteTrafficPolicyInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.DeleteTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(0).(func(*route53.DeleteTrafficPolicyInstanceInput) *route53.DeleteTrafficPolicyInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteTrafficPolicyInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.DeleteTrafficPolicyInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTrafficPolicyInstanceRequest provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteTrafficPolicyInstanceRequest(_a0 *route53.DeleteTrafficPolicyInstanceInput) (*request.Request, *route53.DeleteTrafficPolicyInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.DeleteTrafficPolicyInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.DeleteTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(1).(func(*route53.DeleteTrafficPolicyInstanceInput) *route53.DeleteTrafficPolicyInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.DeleteTrafficPolicyInstanceOutput)
		}
	}

	return r0, r1
}

// DeleteTrafficPolicyInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) DeleteTrafficPolicyInstanceWithContext(_a0 context.Context, _a1 *route53.DeleteTrafficPolicyInstanceInput, _a2 ...request.Option) (*route53.DeleteTrafficPolicyInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.DeleteTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.DeleteTrafficPolicyInstanceInput, ...request.Option) *route53.DeleteTrafficPolicyInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteTrafficPolicyInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.DeleteTrafficPolicyInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTrafficPolicyRequest provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteTrafficPolicyRequest(_a0 *route53.DeleteTrafficPolicyInput) (*request.Request, *route53.DeleteTrafficPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.DeleteTrafficPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.DeleteTrafficPolicyOutput
	if rf, ok := ret.Get(1).(func(*route53.DeleteTrafficPolicyInput) *route53.DeleteTrafficPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.DeleteTrafficPolicyOutput)
		}
	}

	return r0, r1
}

// DeleteTrafficPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) DeleteTrafficPolicyWithContext(_a0 context.Context, _a1 *route53.DeleteTrafficPolicyInput, _a2 ...request.Option) (*route53.DeleteTrafficPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.DeleteTrafficPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.DeleteTrafficPolicyInput, ...request.Option) *route53.DeleteTrafficPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteTrafficPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.DeleteTrafficPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteVPCAssociationAuthorization provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteVPCAssociationAuthorization(_a0 *route53.DeleteVPCAssociationAuthorizationInput) (*route53.DeleteVPCAssociationAuthorizationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.DeleteVPCAssociationAuthorizationOutput
	if rf, ok := ret.Get(0).(func(*route53.DeleteVPCAssociationAuthorizationInput) *route53.DeleteVPCAssociationAuthorizationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteVPCAssociationAuthorizationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.DeleteVPCAssociationAuthorizationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteVPCAssociationAuthorizationRequest provides a mock function with given fields: _a0
func (_m *Route53Client) DeleteVPCAssociationAuthorizationRequest(_a0 *route53.DeleteVPCAssociationAuthorizationInput) (*request.Request, *route53.DeleteVPCAssociationAuthorizationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.DeleteVPCAssociationAuthorizationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.DeleteVPCAssociationAuthorizationOutput
	if rf, ok := ret.Get(1).(func(*route53.DeleteVPCAssociationAuthorizationInput) *route53.DeleteVPCAssociationAuthorizationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.DeleteVPCAssociationAuthorizationOutput)
		}
	}

	return r0, r1
}

// DeleteVPCAssociationAuthorizationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) DeleteVPCAssociationAuthorizationWithContext(_a0 context.Context, _a1 *route53.DeleteVPCAssociationAuthorizationInput, _a2 ...request.Option) (*route53.DeleteVPCAssociationAuthorizationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.DeleteVPCAssociationAuthorizationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.DeleteVPCAssociationAuthorizationInput, ...request.Option) *route53.DeleteVPCAssociationAuthorizationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DeleteVPCAssociationAuthorizationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.DeleteVPCAssociationAuthorizationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateVPCFromHostedZone provides a mock function with given fields: _a0
func (_m *Route53Client) DisassociateVPCFromHostedZone(_a0 *route53.DisassociateVPCFromHostedZoneInput) (*route53.DisassociateVPCFromHostedZoneOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.DisassociateVPCFromHostedZoneOutput
	if rf, ok := ret.Get(0).(func(*route53.DisassociateVPCFromHostedZoneInput) *route53.DisassociateVPCFromHostedZoneOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DisassociateVPCFromHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.DisassociateVPCFromHostedZoneInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateVPCFromHostedZoneRequest provides a mock function with given fields: _a0
func (_m *Route53Client) DisassociateVPCFromHostedZoneRequest(_a0 *route53.DisassociateVPCFromHostedZoneInput) (*request.Request, *route53.DisassociateVPCFromHostedZoneOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.DisassociateVPCFromHostedZoneInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.DisassociateVPCFromHostedZoneOutput
	if rf, ok := ret.Get(1).(func(*route53.DisassociateVPCFromHostedZoneInput) *route53.DisassociateVPCFromHostedZoneOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.DisassociateVPCFromHostedZoneOutput)
		}
	}

	return r0, r1
}

// DisassociateVPCFromHostedZoneWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) DisassociateVPCFromHostedZoneWithContext(_a0 context.Context, _a1 *route53.DisassociateVPCFromHostedZoneInput, _a2 ...request.Option) (*route53.DisassociateVPCFromHostedZoneOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.DisassociateVPCFromHostedZoneOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.DisassociateVPCFromHostedZoneInput, ...request.Option) *route53.DisassociateVPCFromHostedZoneOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.DisassociateVPCFromHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.DisassociateVPCFromHostedZoneInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountLimit provides a mock function with given fields: _a0
func (_m *Route53Client) GetAccountLimit(_a0 *route53.GetAccountLimitInput) (*route53.GetAccountLimitOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetAccountLimitOutput
	if rf, ok := ret.Get(0).(func(*route53.GetAccountLimitInput) *route53.GetAccountLimitOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetAccountLimitOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetAccountLimitInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountLimitRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetAccountLimitRequest(_a0 *route53.GetAccountLimitInput) (*request.Request, *route53.GetAccountLimitOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetAccountLimitInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetAccountLimitOutput
	if rf, ok := ret.Get(1).(func(*route53.GetAccountLimitInput) *route53.GetAccountLimitOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetAccountLimitOutput)
		}
	}

	return r0, r1
}

// GetAccountLimitWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetAccountLimitWithContext(_a0 context.Context, _a1 *route53.GetAccountLimitInput, _a2 ...request.Option) (*route53.GetAccountLimitOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetAccountLimitOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetAccountLimitInput, ...request.Option) *route53.GetAccountLimitOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetAccountLimitOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetAccountLimitInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetChange provides a mock function with given fields: _a0
func (_m *Route53Client) GetChange(_a0 *route53.GetChangeInput) (*route53.GetChangeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetChangeOutput
	if rf, ok := ret.Get(0).(func(*route53.GetChangeInput) *route53.GetChangeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetChangeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetChangeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetChangeRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetChangeRequest(_a0 *route53.GetChangeInput) (*request.Request, *route53.GetChangeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetChangeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetChangeOutput
	if rf, ok := ret.Get(1).(func(*route53.GetChangeInput) *route53.GetChangeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetChangeOutput)
		}
	}

	return r0, r1
}

// GetChangeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetChangeWithContext(_a0 context.Context, _a1 *route53.GetChangeInput, _a2 ...request.Option) (*route53.GetChangeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetChangeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetChangeInput, ...request.Option) *route53.GetChangeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetChangeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetChangeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCheckerIpRanges provides a mock function with given fields: _a0
func (_m *Route53Client) GetCheckerIpRanges(_a0 *route53.GetCheckerIpRangesInput) (*route53.GetCheckerIpRangesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetCheckerIpRangesOutput
	if rf, ok := ret.Get(0).(func(*route53.GetCheckerIpRangesInput) *route53.GetCheckerIpRangesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetCheckerIpRangesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetCheckerIpRangesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCheckerIpRangesRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetCheckerIpRangesRequest(_a0 *route53.GetCheckerIpRangesInput) (*request.Request, *route53.GetCheckerIpRangesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetCheckerIpRangesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetCheckerIpRangesOutput
	if rf, ok := ret.Get(1).(func(*route53.GetCheckerIpRangesInput) *route53.GetCheckerIpRangesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetCheckerIpRangesOutput)
		}
	}

	return r0, r1
}

// GetCheckerIpRangesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetCheckerIpRangesWithContext(_a0 context.Context, _a1 *route53.GetCheckerIpRangesInput, _a2 ...request.Option) (*route53.GetCheckerIpRangesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetCheckerIpRangesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetCheckerIpRangesInput, ...request.Option) *route53.GetCheckerIpRangesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetCheckerIpRangesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetCheckerIpRangesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetGeoLocation provides a mock function with given fields: _a0
func (_m *Route53Client) GetGeoLocation(_a0 *route53.GetGeoLocationInput) (*route53.GetGeoLocationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetGeoLocationOutput
	if rf, ok := ret.Get(0).(func(*route53.GetGeoLocationInput) *route53.GetGeoLocationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetGeoLocationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetGeoLocationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetGeoLocationRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetGeoLocationRequest(_a0 *route53.GetGeoLocationInput) (*request.Request, *route53.GetGeoLocationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetGeoLocationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetGeoLocationOutput
	if rf, ok := ret.Get(1).(func(*route53.GetGeoLocationInput) *route53.GetGeoLocationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetGeoLocationOutput)
		}
	}

	return r0, r1
}

// GetGeoLocationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetGeoLocationWithContext(_a0 context.Context, _a1 *route53.GetGeoLocationInput, _a2 ...request.Option) (*route53.GetGeoLocationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetGeoLocationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetGeoLocationInput, ...request.Option) *route53.GetGeoLocationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetGeoLocationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetGeoLocationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHealthCheck provides a mock function with given fields: _a0
func (_m *Route53Client) GetHealthCheck(_a0 *route53.GetHealthCheckInput) (*route53.GetHealthCheckOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetHealthCheckOutput
	if rf, ok := ret.Get(0).(func(*route53.GetHealthCheckInput) *route53.GetHealthCheckOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHealthCheckOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetHealthCheckInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHealthCheckCount provides a mock function with given fields: _a0
func (_m *Route53Client) GetHealthCheckCount(_a0 *route53.GetHealthCheckCountInput) (*route53.GetHealthCheckCountOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetHealthCheckCountOutput
	if rf, ok := ret.Get(0).(func(*route53.GetHealthCheckCountInput) *route53.GetHealthCheckCountOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHealthCheckCountOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetHealthCheckCountInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHealthCheckCountRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetHealthCheckCountRequest(_a0 *route53.GetHealthCheckCountInput) (*request.Request, *route53.GetHealthCheckCountOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetHealthCheckCountInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetHealthCheckCountOutput
	if rf, ok := ret.Get(1).(func(*route53.GetHealthCheckCountInput) *route53.GetHealthCheckCountOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetHealthCheckCountOutput)
		}
	}

	return r0, r1
}

// GetHealthCheckCountWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetHealthCheckCountWithContext(_a0 context.Context, _a1 *route53.GetHealthCheckCountInput, _a2 ...request.Option) (*route53.GetHealthCheckCountOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetHealthCheckCountOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetHealthCheckCountInput, ...request.Option) *route53.GetHealthCheckCountOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHealthCheckCountOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetHealthCheckCountInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHealthCheckLastFailureReason provides a mock function with given fields: _a0
func (_m *Route53Client) GetHealthCheckLastFailureReason(_a0 *route53.GetHealthCheckLastFailureReasonInput) (*route53.GetHealthCheckLastFailureReasonOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetHealthCheckLastFailureReasonOutput
	if rf, ok := ret.Get(0).(func(*route53.GetHealthCheckLastFailureReasonInput) *route53.GetHealthCheckLastFailureReasonOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHealthCheckLastFailureReasonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetHealthCheckLastFailureReasonInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHealthCheckLastFailureReasonRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetHealthCheckLastFailureReasonRequest(_a0 *route53.GetHealthCheckLastFailureReasonInput) (*request.Request, *route53.GetHealthCheckLastFailureReasonOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetHealthCheckLastFailureReasonInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetHealthCheckLastFailureReasonOutput
	if rf, ok := ret.Get(1).(func(*route53.GetHealthCheckLastFailureReasonInput) *route53.GetHealthCheckLastFailureReasonOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetHealthCheckLastFailureReasonOutput)
		}
	}

	return r0, r1
}

// GetHealthCheckLastFailureReasonWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetHealthCheckLastFailureReasonWithContext(_a0 context.Context, _a1 *route53.GetHealthCheckLastFailureReasonInput, _a2 ...request.Option) (*route53.GetHealthCheckLastFailureReasonOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetHealthCheckLastFailureReasonOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetHealthCheckLastFailureReasonInput, ...request.Option) *route53.GetHealthCheckLastFailureReasonOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHealthCheckLastFailureReasonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetHealthCheckLastFailureReasonInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHealthCheckRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetHealthCheckRequest(_a0 *route53.GetHealthCheckInput) (*request.Request, *route53.GetHealthCheckOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetHealthCheckInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetHealthCheckOutput
	if rf, ok := ret.Get(1).(func(*route53.GetHealthCheckInput) *route53.GetHealthCheckOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetHealthCheckOutput)
		}
	}

	return r0, r1
}

// GetHealthCheckStatus provides a mock function with given fields: _a0
func (_m *Route53Client) GetHealthCheckStatus(_a0 *route53.GetHealthCheckStatusInput) (*route53.GetHealthCheckStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetHealthCheckStatusOutput
	if rf, ok := ret.Get(0).(func(*route53.GetHealthCheckStatusInput) *route53.GetHealthCheckStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHealthCheckStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetHealthCheckStatusInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHealthCheckStatusRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetHealthCheckStatusRequest(_a0 *route53.GetHealthCheckStatusInput) (*request.Request, *route53.GetHealthCheckStatusOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetHealthCheckStatusInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetHealthCheckStatusOutput
	if rf, ok := ret.Get(1).(func(*route53.GetHealthCheckStatusInput) *route53.GetHealthCheckStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetHealthCheckStatusOutput)
		}
	}

	return r0, r1
}

// GetHealthCheckStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetHealthCheckStatusWithContext(_a0 context.Context, _a1 *route53.GetHealthCheckStatusInput, _a2 ...request.Option) (*route53.GetHealthCheckStatusOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetHealthCheckStatusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetHealthCheckStatusInput, ...request.Option) *route53.GetHealthCheckStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHealthCheckStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetHealthCheckStatusInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHealthCheckWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetHealthCheckWithContext(_a0 context.Context, _a1 *route53.GetHealthCheckInput, _a2 ...request.Option) (*route53.GetHealthCheckOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetHealthCheckOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetHealthCheckInput, ...request.Option) *route53.GetHealthCheckOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHealthCheckOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetHealthCheckInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostedZone provides a mock function with given fields: _a0
func (_m *Route53Client) GetHostedZone(_a0 *route53.GetHostedZoneInput) (*route53.GetHostedZoneOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetHostedZoneOutput
	if rf, ok := ret.Get(0).(func(*route53.GetHostedZoneInput) *route53.GetHostedZoneOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetHostedZoneInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostedZoneCount provides a mock function with given fields: _a0
func (_m *Route53Client) GetHostedZoneCount(_a0 *route53.GetHostedZoneCountInput) (*route53.GetHostedZoneCountOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetHostedZoneCountOutput
	if rf, ok := ret.Get(0).(func(*route53.GetHostedZoneCountInput) *route53.GetHostedZoneCountOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHostedZoneCountOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetHostedZoneCountInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostedZoneCountRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetHostedZoneCountRequest(_a0 *route53.GetHostedZoneCountInput) (*request.Request, *route53.GetHostedZoneCountOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetHostedZoneCountInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetHostedZoneCountOutput
	if rf, ok := ret.Get(1).(func(*route53.GetHostedZoneCountInput) *route53.GetHostedZoneCountOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetHostedZoneCountOutput)
		}
	}

	return r0, r1
}

// GetHostedZoneCountWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetHostedZoneCountWithContext(_a0 context.Context, _a1 *route53.GetHostedZoneCountInput, _a2 ...request.Option) (*route53.GetHostedZoneCountOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetHostedZoneCountOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetHostedZoneCountInput, ...request.Option) *route53.GetHostedZoneCountOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHostedZoneCountOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetHostedZoneCountInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostedZoneLimit provides a mock function with given fields: _a0
func (_m *Route53Client) GetHostedZoneLimit(_a0 *route53.GetHostedZoneLimitInput) (*route53.GetHostedZoneLimitOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetHostedZoneLimitOutput
	if rf, ok := ret.Get(0).(func(*route53.GetHostedZoneLimitInput) *route53.GetHostedZoneLimitOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHostedZoneLimitOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetHostedZoneLimitInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostedZoneLimitRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetHostedZoneLimitRequest(_a0 *route53.GetHostedZoneLimitInput) (*request.Request, *route53.GetHostedZoneLimitOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetHostedZoneLimitInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetHostedZoneLimitOutput
	if rf, ok := ret.Get(1).(func(*route53.GetHostedZoneLimitInput) *route53.GetHostedZoneLimitOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetHostedZoneLimitOutput)
		}
	}

	return r0, r1
}

// GetHostedZoneLimitWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetHostedZoneLimitWithContext(_a0 context.Context, _a1 *route53.GetHostedZoneLimitInput, _a2 ...request.Option) (*route53.GetHostedZoneLimitOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetHostedZoneLimitOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetHostedZoneLimitInput, ...request.Option) *route53.GetHostedZoneLimitOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHostedZoneLimitOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetHostedZoneLimitInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostedZoneRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetHostedZoneRequest(_a0 *route53.GetHostedZoneInput) (*request.Request, *route53.GetHostedZoneOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetHostedZoneInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetHostedZoneOutput
	if rf, ok := ret.Get(1).(func(*route53.GetHostedZoneInput) *route53.GetHostedZoneOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetHostedZoneOutput)
		}
	}

	return r0, r1
}

// GetHostedZoneWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetHostedZoneWithContext(_a0 context.Context, _a1 *route53.GetHostedZoneInput, _a2 ...request.Option) (*route53.GetHostedZoneOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetHostedZoneOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetHostedZoneInput, ...request.Option) *route53.GetHostedZoneOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetHostedZoneInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetQueryLoggingConfig provides a mock function with given fields: _a0
func (_m *Route53Client) GetQueryLoggingConfig(_a0 *route53.GetQueryLoggingConfigInput) (*route53.GetQueryLoggingConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetQueryLoggingConfigOutput
	if rf, ok := ret.Get(0).(func(*route53.GetQueryLoggingConfigInput) *route53.GetQueryLoggingConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetQueryLoggingConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetQueryLoggingConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetQueryLoggingConfigRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetQueryLoggingConfigRequest(_a0 *route53.GetQueryLoggingConfigInput) (*request.Request, *route53.GetQueryLoggingConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetQueryLoggingConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetQueryLoggingConfigOutput
	if rf, ok := ret.Get(1).(func(*route53.GetQueryLoggingConfigInput) *route53.GetQueryLoggingConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetQueryLoggingConfigOutput)
		}
	}

	return r0, r1
}

// GetQueryLoggingConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetQueryLoggingConfigWithContext(_a0 context.Context, _a1 *route53.GetQueryLoggingConfigInput, _a2 ...request.Option) (*route53.GetQueryLoggingConfigOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetQueryLoggingConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetQueryLoggingConfigInput, ...request.Option) *route53.GetQueryLoggingConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetQueryLoggingConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetQueryLoggingConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetReusableDelegationSet provides a mock function with given fields: _a0
func (_m *Route53Client) GetReusableDelegationSet(_a0 *route53.GetReusableDelegationSetInput) (*route53.GetReusableDelegationSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetReusableDelegationSetOutput
	if rf, ok := ret.Get(0).(func(*route53.GetReusableDelegationSetInput) *route53.GetReusableDelegationSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetReusableDelegationSetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetReusableDelegationSetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetReusableDelegationSetLimit provides a mock function with given fields: _a0
func (_m *Route53Client) GetReusableDelegationSetLimit(_a0 *route53.GetReusableDelegationSetLimitInput) (*route53.GetReusableDelegationSetLimitOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetReusableDelegationSetLimitOutput
	if rf, ok := ret.Get(0).(func(*route53.GetReusableDelegationSetLimitInput) *route53.GetReusableDelegationSetLimitOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetReusableDelegationSetLimitOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetReusableDelegationSetLimitInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetReusableDelegationSetLimitRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetReusableDelegationSetLimitRequest(_a0 *route53.GetReusableDelegationSetLimitInput) (*request.Request, *route53.GetReusableDelegationSetLimitOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetReusableDelegationSetLimitInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetReusableDelegationSetLimitOutput
	if rf, ok := ret.Get(1).(func(*route53.GetReusableDelegationSetLimitInput) *route53.GetReusableDelegationSetLimitOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetReusableDelegationSetLimitOutput)
		}
	}

	return r0, r1
}

// GetReusableDelegationSetLimitWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetReusableDelegationSetLimitWithContext(_a0 context.Context, _a1 *route53.GetReusableDelegationSetLimitInput, _a2 ...request.Option) (*route53.GetReusableDelegationSetLimitOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetReusableDelegationSetLimitOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetReusableDelegationSetLimitInput, ...request.Option) *route53.GetReusableDelegationSetLimitOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetReusableDelegationSetLimitOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetReusableDelegationSetLimitInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetReusableDelegationSetRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetReusableDelegationSetRequest(_a0 *route53.GetReusableDelegationSetInput) (*request.Request, *route53.GetReusableDelegationSetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetReusableDelegationSetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetReusableDelegationSetOutput
	if rf, ok := ret.Get(1).(func(*route53.GetReusableDelegationSetInput) *route53.GetReusableDelegationSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetReusableDelegationSetOutput)
		}
	}

	return r0, r1
}

// GetReusableDelegationSetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetReusableDelegationSetWithContext(_a0 context.Context, _a1 *route53.GetReusableDelegationSetInput, _a2 ...request.Option) (*route53.GetReusableDelegationSetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetReusableDelegationSetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetReusableDelegationSetInput, ...request.Option) *route53.GetReusableDelegationSetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetReusableDelegationSetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetReusableDelegationSetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTrafficPolicy provides a mock function with given fields: _a0
func (_m *Route53Client) GetTrafficPolicy(_a0 *route53.GetTrafficPolicyInput) (*route53.GetTrafficPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetTrafficPolicyOutput
	if rf, ok := ret.Get(0).(func(*route53.GetTrafficPolicyInput) *route53.GetTrafficPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetTrafficPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetTrafficPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTrafficPolicyInstance provides a mock function with given fields: _a0
func (_m *Route53Client) GetTrafficPolicyInstance(_a0 *route53.GetTrafficPolicyInstanceInput) (*route53.GetTrafficPolicyInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(0).(func(*route53.GetTrafficPolicyInstanceInput) *route53.GetTrafficPolicyInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetTrafficPolicyInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetTrafficPolicyInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTrafficPolicyInstanceCount provides a mock function with given fields: _a0
func (_m *Route53Client) GetTrafficPolicyInstanceCount(_a0 *route53.GetTrafficPolicyInstanceCountInput) (*route53.GetTrafficPolicyInstanceCountOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.GetTrafficPolicyInstanceCountOutput
	if rf, ok := ret.Get(0).(func(*route53.GetTrafficPolicyInstanceCountInput) *route53.GetTrafficPolicyInstanceCountOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetTrafficPolicyInstanceCountOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.GetTrafficPolicyInstanceCountInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTrafficPolicyInstanceCountRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetTrafficPolicyInstanceCountRequest(_a0 *route53.GetTrafficPolicyInstanceCountInput) (*request.Request, *route53.GetTrafficPolicyInstanceCountOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetTrafficPolicyInstanceCountInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetTrafficPolicyInstanceCountOutput
	if rf, ok := ret.Get(1).(func(*route53.GetTrafficPolicyInstanceCountInput) *route53.GetTrafficPolicyInstanceCountOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetTrafficPolicyInstanceCountOutput)
		}
	}

	return r0, r1
}

// GetTrafficPolicyInstanceCountWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetTrafficPolicyInstanceCountWithContext(_a0 context.Context, _a1 *route53.GetTrafficPolicyInstanceCountInput, _a2 ...request.Option) (*route53.GetTrafficPolicyInstanceCountOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetTrafficPolicyInstanceCountOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetTrafficPolicyInstanceCountInput, ...request.Option) *route53.GetTrafficPolicyInstanceCountOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetTrafficPolicyInstanceCountOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetTrafficPolicyInstanceCountInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTrafficPolicyInstanceRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetTrafficPolicyInstanceRequest(_a0 *route53.GetTrafficPolicyInstanceInput) (*request.Request, *route53.GetTrafficPolicyInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetTrafficPolicyInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(1).(func(*route53.GetTrafficPolicyInstanceInput) *route53.GetTrafficPolicyInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetTrafficPolicyInstanceOutput)
		}
	}

	return r0, r1
}

// GetTrafficPolicyInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetTrafficPolicyInstanceWithContext(_a0 context.Context, _a1 *route53.GetTrafficPolicyInstanceInput, _a2 ...request.Option) (*route53.GetTrafficPolicyInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetTrafficPolicyInstanceInput, ...request.Option) *route53.GetTrafficPolicyInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetTrafficPolicyInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetTrafficPolicyInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTrafficPolicyRequest provides a mock function with given fields: _a0
func (_m *Route53Client) GetTrafficPolicyRequest(_a0 *route53.GetTrafficPolicyInput) (*request.Request, *route53.GetTrafficPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.GetTrafficPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.GetTrafficPolicyOutput
	if rf, ok := ret.Get(1).(func(*route53.GetTrafficPolicyInput) *route53.GetTrafficPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.GetTrafficPolicyOutput)
		}
	}

	return r0, r1
}

// GetTrafficPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) GetTrafficPolicyWithContext(_a0 context.Context, _a1 *route53.GetTrafficPolicyInput, _a2 ...request.Option) (*route53.GetTrafficPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.GetTrafficPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetTrafficPolicyInput, ...request.Option) *route53.GetTrafficPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.GetTrafficPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.GetTrafficPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGeoLocations provides a mock function with given fields: _a0
func (_m *Route53Client) ListGeoLocations(_a0 *route53.ListGeoLocationsInput) (*route53.ListGeoLocationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListGeoLocationsOutput
	if rf, ok := ret.Get(0).(func(*route53.ListGeoLocationsInput) *route53.ListGeoLocationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListGeoLocationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListGeoLocationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGeoLocationsRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListGeoLocationsRequest(_a0 *route53.ListGeoLocationsInput) (*request.Request, *route53.ListGeoLocationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListGeoLocationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListGeoLocationsOutput
	if rf, ok := ret.Get(1).(func(*route53.ListGeoLocationsInput) *route53.ListGeoLocationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListGeoLocationsOutput)
		}
	}

	return r0, r1
}

// ListGeoLocationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListGeoLocationsWithContext(_a0 context.Context, _a1 *route53.ListGeoLocationsInput, _a2 ...request.Option) (*route53.ListGeoLocationsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListGeoLocationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListGeoLocationsInput, ...request.Option) *route53.ListGeoLocationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListGeoLocationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListGeoLocationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHealthChecks provides a mock function with given fields: _a0
func (_m *Route53Client) ListHealthChecks(_a0 *route53.ListHealthChecksInput) (*route53.ListHealthChecksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListHealthChecksOutput
	if rf, ok := ret.Get(0).(func(*route53.ListHealthChecksInput) *route53.ListHealthChecksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListHealthChecksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListHealthChecksInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHealthChecksPages provides a mock function with given fields: _a0, _a1
func (_m *Route53Client) ListHealthChecksPages(_a0 *route53.ListHealthChecksInput, _a1 func(*route53.ListHealthChecksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*route53.ListHealthChecksInput, func(*route53.ListHealthChecksOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListHealthChecksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *Route53Client) ListHealthChecksPagesWithContext(_a0 context.Context, _a1 *route53.ListHealthChecksInput, _a2 func(*route53.ListHealthChecksOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListHealthChecksInput, func(*route53.ListHealthChecksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListHealthChecksRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListHealthChecksRequest(_a0 *route53.ListHealthChecksInput) (*request.Request, *route53.ListHealthChecksOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListHealthChecksInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListHealthChecksOutput
	if rf, ok := ret.Get(1).(func(*route53.ListHealthChecksInput) *route53.ListHealthChecksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListHealthChecksOutput)
		}
	}

	return r0, r1
}

// ListHealthChecksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListHealthChecksWithContext(_a0 context.Context, _a1 *route53.ListHealthChecksInput, _a2 ...request.Option) (*route53.ListHealthChecksOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListHealthChecksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListHealthChecksInput, ...request.Option) *route53.ListHealthChecksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListHealthChecksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListHealthChecksInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHostedZones provides a mock function with given fields: _a0
func (_m *Route53Client) ListHostedZones(_a0 *route53.ListHostedZonesInput) (*route53.ListHostedZonesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListHostedZonesOutput
	if rf, ok := ret.Get(0).(func(*route53.ListHostedZonesInput) *route53.ListHostedZonesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListHostedZonesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListHostedZonesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHostedZonesByName provides a mock function with given fields: _a0
func (_m *Route53Client) ListHostedZonesByName(_a0 *route53.ListHostedZonesByNameInput) (*route53.ListHostedZonesByNameOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListHostedZonesByNameOutput
	if rf, ok := ret.Get(0).(func(*route53.ListHostedZonesByNameInput) *route53.ListHostedZonesByNameOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListHostedZonesByNameOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListHostedZonesByNameInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHostedZonesByNameRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListHostedZonesByNameRequest(_a0 *route53.ListHostedZonesByNameInput) (*request.Request, *route53.ListHostedZonesByNameOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListHostedZonesByNameInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListHostedZonesByNameOutput
	if rf, ok := ret.Get(1).(func(*route53.ListHostedZonesByNameInput) *route53.ListHostedZonesByNameOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListHostedZonesByNameOutput)
		}
	}

	return r0, r1
}

// ListHostedZonesByNameWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListHostedZonesByNameWithContext(_a0 context.Context, _a1 *route53.ListHostedZonesByNameInput, _a2 ...request.Option) (*route53.ListHostedZonesByNameOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListHostedZonesByNameOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListHostedZonesByNameInput, ...request.Option) *route53.ListHostedZonesByNameOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListHostedZonesByNameOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListHostedZonesByNameInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHostedZonesByVPC provides a mock function with given fields: _a0
func (_m *Route53Client) ListHostedZonesByVPC(_a0 *route53.ListHostedZonesByVPCInput) (*route53.ListHostedZonesByVPCOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListHostedZonesByVPCOutput
	if rf, ok := ret.Get(0).(func(*route53.ListHostedZonesByVPCInput) *route53.ListHostedZonesByVPCOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListHostedZonesByVPCOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListHostedZonesByVPCInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHostedZonesByVPCRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListHostedZonesByVPCRequest(_a0 *route53.ListHostedZonesByVPCInput) (*request.Request, *route53.ListHostedZonesByVPCOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListHostedZonesByVPCInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListHostedZonesByVPCOutput
	if rf, ok := ret.Get(1).(func(*route53.ListHostedZonesByVPCInput) *route53.ListHostedZonesByVPCOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListHostedZonesByVPCOutput)
		}
	}

	return r0, r1
}

// ListHostedZonesByVPCWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListHostedZonesByVPCWithContext(_a0 context.Context, _a1 *route53.ListHostedZonesByVPCInput, _a2 ...request.Option) (*route53.ListHostedZonesByVPCOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListHostedZonesByVPCOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListHostedZonesByVPCInput, ...request.Option) *route53.ListHostedZonesByVPCOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListHostedZonesByVPCOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListHostedZonesByVPCInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListHostedZonesPages provides a mock function with given fields: _a0, _a1
func (_m *Route53Client) ListHostedZonesPages(_a0 *route53.ListHostedZonesInput, _a1 func(*route53.ListHostedZonesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*route53.ListHostedZonesInput, func(*route53.ListHostedZonesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListHostedZonesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *Route53Client) ListHostedZonesPagesWithContext(_a0 context.Context, _a1 *route53.ListHostedZonesInput, _a2 func(*route53.ListHostedZonesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListHostedZonesInput, func(*route53.ListHostedZonesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListHostedZonesRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListHostedZonesRequest(_a0 *route53.ListHostedZonesInput) (*request.Request, *route53.ListHostedZonesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListHostedZonesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListHostedZonesOutput
	if rf, ok := ret.Get(1).(func(*route53.ListHostedZonesInput) *route53.ListHostedZonesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListHostedZonesOutput)
		}
	}

	return r0, r1
}

// ListHostedZonesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListHostedZonesWithContext(_a0 context.Context, _a1 *route53.ListHostedZonesInput, _a2 ...request.Option) (*route53.ListHostedZonesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListHostedZonesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListHostedZonesInput, ...request.Option) *route53.ListHostedZonesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListHostedZonesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListHostedZonesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListQueryLoggingConfigs provides a mock function with given fields: _a0
func (_m *Route53Client) ListQueryLoggingConfigs(_a0 *route53.ListQueryLoggingConfigsInput) (*route53.ListQueryLoggingConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListQueryLoggingConfigsOutput
	if rf, ok := ret.Get(0).(func(*route53.ListQueryLoggingConfigsInput) *route53.ListQueryLoggingConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListQueryLoggingConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListQueryLoggingConfigsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListQueryLoggingConfigsPages provides a mock function with given fields: _a0, _a1
func (_m *Route53Client) ListQueryLoggingConfigsPages(_a0 *route53.ListQueryLoggingConfigsInput, _a1 func(*route53.ListQueryLoggingConfigsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*route53.ListQueryLoggingConfigsInput, func(*route53.ListQueryLoggingConfigsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListQueryLoggingConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *Route53Client) ListQueryLoggingConfigsPagesWithContext(_a0 context.Context, _a1 *route53.ListQueryLoggingConfigsInput, _a2 func(*route53.ListQueryLoggingConfigsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListQueryLoggingConfigsInput, func(*route53.ListQueryLoggingConfigsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListQueryLoggingConfigsRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListQueryLoggingConfigsRequest(_a0 *route53.ListQueryLoggingConfigsInput) (*request.Request, *route53.ListQueryLoggingConfigsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListQueryLoggingConfigsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListQueryLoggingConfigsOutput
	if rf, ok := ret.Get(1).(func(*route53.ListQueryLoggingConfigsInput) *route53.ListQueryLoggingConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListQueryLoggingConfigsOutput)
		}
	}

	return r0, r1
}

// ListQueryLoggingConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListQueryLoggingConfigsWithContext(_a0 context.Context, _a1 *route53.ListQueryLoggingConfigsInput, _a2 ...request.Option) (*route53.ListQueryLoggingConfigsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListQueryLoggingConfigsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListQueryLoggingConfigsInput, ...request.Option) *route53.ListQueryLoggingConfigsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListQueryLoggingConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListQueryLoggingConfigsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListResourceRecordSets provides a mock function with given fields: _a0
func (_m *Route53Client) ListResourceRecordSets(_a0 *route53.ListResourceRecordSetsInput) (*route53.ListResourceRecordSetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListResourceRecordSetsOutput
	if rf, ok := ret.Get(0).(func(*route53.ListResourceRecordSetsInput) *route53.ListResourceRecordSetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListResourceRecordSetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListResourceRecordSetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListResourceRecordSetsPages provides a mock function with given fields: _a0, _a1
func (_m *Route53Client) ListResourceRecordSetsPages(_a0 *route53.ListResourceRecordSetsInput, _a1 func(*route53.ListResourceRecordSetsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*route53.ListResourceRecordSetsInput, func(*route53.ListResourceRecordSetsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListResourceRecordSetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *Route53Client) ListResourceRecordSetsPagesWithContext(_a0 context.Context, _a1 *route53.ListResourceRecordSetsInput, _a2 func(*route53.ListResourceRecordSetsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListResourceRecordSetsInput, func(*route53.ListResourceRecordSetsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListResourceRecordSetsRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListResourceRecordSetsRequest(_a0 *route53.ListResourceRecordSetsInput) (*request.Request, *route53.ListResourceRecordSetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListResourceRecordSetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListResourceRecordSetsOutput
	if rf, ok := ret.Get(1).(func(*route53.ListResourceRecordSetsInput) *route53.ListResourceRecordSetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListResourceRecordSetsOutput)
		}
	}

	return r0, r1
}

// ListResourceRecordSetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListResourceRecordSetsWithContext(_a0 context.Context, _a1 *route53.ListResourceRecordSetsInput, _a2 ...request.Option) (*route53.ListResourceRecordSetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListResourceRecordSetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListResourceRecordSetsInput, ...request.Option) *route53.ListResourceRecordSetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListResourceRecordSetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListResourceRecordSetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListReusableDelegationSets provides a mock function with given fields: _a0
func (_m *Route53Client) ListReusableDelegationSets(_a0 *route53.ListReusableDelegationSetsInput) (*route53.ListReusableDelegationSetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListReusableDelegationSetsOutput
	if rf, ok := ret.Get(0).(func(*route53.ListReusableDelegationSetsInput) *route53.ListReusableDelegationSetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListReusableDelegationSetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListReusableDelegationSetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListReusableDelegationSetsRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListReusableDelegationSetsRequest(_a0 *route53.ListReusableDelegationSetsInput) (*request.Request, *route53.ListReusableDelegationSetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListReusableDelegationSetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListReusableDelegationSetsOutput
	if rf, ok := ret.Get(1).(func(*route53.ListReusableDelegationSetsInput) *route53.ListReusableDelegationSetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListReusableDelegationSetsOutput)
		}
	}

	return r0, r1
}

// ListReusableDelegationSetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListReusableDelegationSetsWithContext(_a0 context.Context, _a1 *route53.ListReusableDelegationSetsInput, _a2 ...request.Option) (*route53.ListReusableDelegationSetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListReusableDelegationSetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListReusableDelegationSetsInput, ...request.Option) *route53.ListReusableDelegationSetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListReusableDelegationSetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListReusableDelegationSetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResource provides a mock function with given fields: _a0
func (_m *Route53Client) ListTagsForResource(_a0 *route53.ListTagsForResourceInput) (*route53.ListTagsForResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(*route53.ListTagsForResourceInput) *route53.ListTagsForResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListTagsForResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResourceRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListTagsForResourceRequest(_a0 *route53.ListTagsForResourceInput) (*request.Request, *route53.ListTagsForResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListTagsForResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListTagsForResourceOutput
	if rf, ok := ret.Get(1).(func(*route53.ListTagsForResourceInput) *route53.ListTagsForResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListTagsForResourceOutput)
		}
	}

	return r0, r1
}

// ListTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListTagsForResourceWithContext(_a0 context.Context, _a1 *route53.ListTagsForResourceInput, _a2 ...request.Option) (*route53.ListTagsForResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListTagsForResourceInput, ...request.Option) *route53.ListTagsForResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListTagsForResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResources provides a mock function with given fields: _a0
func (_m *Route53Client) ListTagsForResources(_a0 *route53.ListTagsForResourcesInput) (*route53.ListTagsForResourcesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListTagsForResourcesOutput
	if rf, ok := ret.Get(0).(func(*route53.ListTagsForResourcesInput) *route53.ListTagsForResourcesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTagsForResourcesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListTagsForResourcesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResourcesRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListTagsForResourcesRequest(_a0 *route53.ListTagsForResourcesInput) (*request.Request, *route53.ListTagsForResourcesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListTagsForResourcesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListTagsForResourcesOutput
	if rf, ok := ret.Get(1).(func(*route53.ListTagsForResourcesInput) *route53.ListTagsForResourcesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListTagsForResourcesOutput)
		}
	}

	return r0, r1
}

// ListTagsForResourcesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListTagsForResourcesWithContext(_a0 context.Context, _a1 *route53.ListTagsForResourcesInput, _a2 ...request.Option) (*route53.ListTagsForResourcesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListTagsForResourcesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListTagsForResourcesInput, ...request.Option) *route53.ListTagsForResourcesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTagsForResourcesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListTagsForResourcesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicies provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicies(_a0 *route53.ListTrafficPoliciesInput) (*route53.ListTrafficPoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListTrafficPoliciesOutput
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPoliciesInput) *route53.ListTrafficPoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPoliciesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPoliciesRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPoliciesRequest(_a0 *route53.ListTrafficPoliciesInput) (*request.Request, *route53.ListTrafficPoliciesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPoliciesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListTrafficPoliciesOutput
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPoliciesInput) *route53.ListTrafficPoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListTrafficPoliciesOutput)
		}
	}

	return r0, r1
}

// ListTrafficPoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListTrafficPoliciesWithContext(_a0 context.Context, _a1 *route53.ListTrafficPoliciesInput, _a2 ...request.Option) (*route53.ListTrafficPoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListTrafficPoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListTrafficPoliciesInput, ...request.Option) *route53.ListTrafficPoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListTrafficPoliciesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicyInstances provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicyInstances(_a0 *route53.ListTrafficPolicyInstancesInput) (*route53.ListTrafficPolicyInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListTrafficPolicyInstancesOutput
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPolicyInstancesInput) *route53.ListTrafficPolicyInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPolicyInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPolicyInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicyInstancesByHostedZone provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicyInstancesByHostedZone(_a0 *route53.ListTrafficPolicyInstancesByHostedZoneInput) (*route53.ListTrafficPolicyInstancesByHostedZoneOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListTrafficPolicyInstancesByHostedZoneOutput
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPolicyInstancesByHostedZoneInput) *route53.ListTrafficPolicyInstancesByHostedZoneOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPolicyInstancesByHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPolicyInstancesByHostedZoneInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicyInstancesByHostedZoneRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicyInstancesByHostedZoneRequest(_a0 *route53.ListTrafficPolicyInstancesByHostedZoneInput) (*request.Request, *route53.ListTrafficPolicyInstancesByHostedZoneOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPolicyInstancesByHostedZoneInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListTrafficPolicyInstancesByHostedZoneOutput
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPolicyInstancesByHostedZoneInput) *route53.ListTrafficPolicyInstancesByHostedZoneOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListTrafficPolicyInstancesByHostedZoneOutput)
		}
	}

	return r0, r1
}

// ListTrafficPolicyInstancesByHostedZoneWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListTrafficPolicyInstancesByHostedZoneWithContext(_a0 context.Context, _a1 *route53.ListTrafficPolicyInstancesByHostedZoneInput, _a2 ...request.Option) (*route53.ListTrafficPolicyInstancesByHostedZoneOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListTrafficPolicyInstancesByHostedZoneOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListTrafficPolicyInstancesByHostedZoneInput, ...request.Option) *route53.ListTrafficPolicyInstancesByHostedZoneOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPolicyInstancesByHostedZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListTrafficPolicyInstancesByHostedZoneInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicyInstancesByPolicy provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicyInstancesByPolicy(_a0 *route53.ListTrafficPolicyInstancesByPolicyInput) (*route53.ListTrafficPolicyInstancesByPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListTrafficPolicyInstancesByPolicyOutput
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPolicyInstancesByPolicyInput) *route53.ListTrafficPolicyInstancesByPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPolicyInstancesByPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPolicyInstancesByPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicyInstancesByPolicyRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicyInstancesByPolicyRequest(_a0 *route53.ListTrafficPolicyInstancesByPolicyInput) (*request.Request, *route53.ListTrafficPolicyInstancesByPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPolicyInstancesByPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListTrafficPolicyInstancesByPolicyOutput
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPolicyInstancesByPolicyInput) *route53.ListTrafficPolicyInstancesByPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListTrafficPolicyInstancesByPolicyOutput)
		}
	}

	return r0, r1
}

// ListTrafficPolicyInstancesByPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListTrafficPolicyInstancesByPolicyWithContext(_a0 context.Context, _a1 *route53.ListTrafficPolicyInstancesByPolicyInput, _a2 ...request.Option) (*route53.ListTrafficPolicyInstancesByPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListTrafficPolicyInstancesByPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListTrafficPolicyInstancesByPolicyInput, ...request.Option) *route53.ListTrafficPolicyInstancesByPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPolicyInstancesByPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListTrafficPolicyInstancesByPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicyInstancesRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicyInstancesRequest(_a0 *route53.ListTrafficPolicyInstancesInput) (*request.Request, *route53.ListTrafficPolicyInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPolicyInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListTrafficPolicyInstancesOutput
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPolicyInstancesInput) *route53.ListTrafficPolicyInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListTrafficPolicyInstancesOutput)
		}
	}

	return r0, r1
}

// ListTrafficPolicyInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListTrafficPolicyInstancesWithContext(_a0 context.Context, _a1 *route53.ListTrafficPolicyInstancesInput, _a2 ...request.Option) (*route53.ListTrafficPolicyInstancesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListTrafficPolicyInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListTrafficPolicyInstancesInput, ...request.Option) *route53.ListTrafficPolicyInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPolicyInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListTrafficPolicyInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicyVersions provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicyVersions(_a0 *route53.ListTrafficPolicyVersionsInput) (*route53.ListTrafficPolicyVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListTrafficPolicyVersionsOutput
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPolicyVersionsInput) *route53.ListTrafficPolicyVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPolicyVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPolicyVersionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTrafficPolicyVersionsRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListTrafficPolicyVersionsRequest(_a0 *route53.ListTrafficPolicyVersionsInput) (*request.Request, *route53.ListTrafficPolicyVersionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListTrafficPolicyVersionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListTrafficPolicyVersionsOutput
	if rf, ok := ret.Get(1).(func(*route53.ListTrafficPolicyVersionsInput) *route53.ListTrafficPolicyVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListTrafficPolicyVersionsOutput)
		}
	}

	return r0, r1
}

// ListTrafficPolicyVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListTrafficPolicyVersionsWithContext(_a0 context.Context, _a1 *route53.ListTrafficPolicyVersionsInput, _a2 ...request.Option) (*route53.ListTrafficPolicyVersionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListTrafficPolicyVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListTrafficPolicyVersionsInput, ...request.Option) *route53.ListTrafficPolicyVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListTrafficPolicyVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListTrafficPolicyVersionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListVPCAssociationAuthorizations provides a mock function with given fields: _a0
func (_m *Route53Client) ListVPCAssociationAuthorizations(_a0 *route53.ListVPCAssociationAuthorizationsInput) (*route53.ListVPCAssociationAuthorizationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.ListVPCAssociationAuthorizationsOutput
	if rf, ok := ret.Get(0).(func(*route53.ListVPCAssociationAuthorizationsInput) *route53.ListVPCAssociationAuthorizationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListVPCAssociationAuthorizationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.ListVPCAssociationAuthorizationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListVPCAssociationAuthorizationsRequest provides a mock function with given fields: _a0
func (_m *Route53Client) ListVPCAssociationAuthorizationsRequest(_a0 *route53.ListVPCAssociationAuthorizationsInput) (*request.Request, *route53.ListVPCAssociationAuthorizationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.ListVPCAssociationAuthorizationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.ListVPCAssociationAuthorizationsOutput
	if rf, ok := ret.Get(1).(func(*route53.ListVPCAssociationAuthorizationsInput) *route53.ListVPCAssociationAuthorizationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.ListVPCAssociationAuthorizationsOutput)
		}
	}

	return r0, r1
}

// ListVPCAssociationAuthorizationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) ListVPCAssociationAuthorizationsWithContext(_a0 context.Context, _a1 *route53.ListVPCAssociationAuthorizationsInput, _a2 ...request.Option) (*route53.ListVPCAssociationAuthorizationsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.ListVPCAssociationAuthorizationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.ListVPCAssociationAuthorizationsInput, ...request.Option) *route53.ListVPCAssociationAuthorizationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.ListVPCAssociationAuthorizationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.ListVPCAssociationAuthorizationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TestDNSAnswer provides a mock function with given fields: _a0
func (_m *Route53Client) TestDNSAnswer(_a0 *route53.TestDNSAnswerInput) (*route53.TestDNSAnswerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.TestDNSAnswerOutput
	if rf, ok := ret.Get(0).(func(*route53.TestDNSAnswerInput) *route53.TestDNSAnswerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.TestDNSAnswerOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.TestDNSAnswerInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TestDNSAnswerRequest provides a mock function with given fields: _a0
func (_m *Route53Client) TestDNSAnswerRequest(_a0 *route53.TestDNSAnswerInput) (*request.Request, *route53.TestDNSAnswerOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.TestDNSAnswerInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.TestDNSAnswerOutput
	if rf, ok := ret.Get(1).(func(*route53.TestDNSAnswerInput) *route53.TestDNSAnswerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.TestDNSAnswerOutput)
		}
	}

	return r0, r1
}

// TestDNSAnswerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) TestDNSAnswerWithContext(_a0 context.Context, _a1 *route53.TestDNSAnswerInput, _a2 ...request.Option) (*route53.TestDNSAnswerOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.TestDNSAnswerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.TestDNSAnswerInput, ...request.Option) *route53.TestDNSAnswerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.TestDNSAnswerOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.TestDNSAnswerInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateHealthCheck provides a mock function with given fields: _a0
func (_m *Route53Client) UpdateHealthCheck(_a0 *route53.UpdateHealthCheckInput) (*route53.UpdateHealthCheckOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.UpdateHealthCheckOutput
	if rf, ok := ret.Get(0).(func(*route53.UpdateHealthCheckInput) *route53.UpdateHealthCheckOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.UpdateHealthCheckOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.UpdateHealthCheckInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateHealthCheckRequest provides a mock function with given fields: _a0
func (_m *Route53Client) UpdateHealthCheckRequest(_a0 *route53.UpdateHealthCheckInput) (*request.Request, *route53.UpdateHealthCheckOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.UpdateHealthCheckInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.UpdateHealthCheckOutput
	if rf, ok := ret.Get(1).(func(*route53.UpdateHealthCheckInput) *route53.UpdateHealthCheckOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.UpdateHealthCheckOutput)
		}
	}

	return r0, r1
}

// UpdateHealthCheckWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) UpdateHealthCheckWithContext(_a0 context.Context, _a1 *route53.UpdateHealthCheckInput, _a2 ...request.Option) (*route53.UpdateHealthCheckOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.UpdateHealthCheckOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.UpdateHealthCheckInput, ...request.Option) *route53.UpdateHealthCheckOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.UpdateHealthCheckOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.UpdateHealthCheckInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateHostedZoneComment provides a mock function with given fields: _a0
func (_m *Route53Client) UpdateHostedZoneComment(_a0 *route53.UpdateHostedZoneCommentInput) (*route53.UpdateHostedZoneCommentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.UpdateHostedZoneCommentOutput
	if rf, ok := ret.Get(0).(func(*route53.UpdateHostedZoneCommentInput) *route53.UpdateHostedZoneCommentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.UpdateHostedZoneCommentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.UpdateHostedZoneCommentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateHostedZoneCommentRequest provides a mock function with given fields: _a0
func (_m *Route53Client) UpdateHostedZoneCommentRequest(_a0 *route53.UpdateHostedZoneCommentInput) (*request.Request, *route53.UpdateHostedZoneCommentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.UpdateHostedZoneCommentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.UpdateHostedZoneCommentOutput
	if rf, ok := ret.Get(1).(func(*route53.UpdateHostedZoneCommentInput) *route53.UpdateHostedZoneCommentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.UpdateHostedZoneCommentOutput)
		}
	}

	return r0, r1
}

// UpdateHostedZoneCommentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) UpdateHostedZoneCommentWithContext(_a0 context.Context, _a1 *route53.UpdateHostedZoneCommentInput, _a2 ...request.Option) (*route53.UpdateHostedZoneCommentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.UpdateHostedZoneCommentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.UpdateHostedZoneCommentInput, ...request.Option) *route53.UpdateHostedZoneCommentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.UpdateHostedZoneCommentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.UpdateHostedZoneCommentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrafficPolicyComment provides a mock function with given fields: _a0
func (_m *Route53Client) UpdateTrafficPolicyComment(_a0 *route53.UpdateTrafficPolicyCommentInput) (*route53.UpdateTrafficPolicyCommentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.UpdateTrafficPolicyCommentOutput
	if rf, ok := ret.Get(0).(func(*route53.UpdateTrafficPolicyCommentInput) *route53.UpdateTrafficPolicyCommentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.UpdateTrafficPolicyCommentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.UpdateTrafficPolicyCommentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrafficPolicyCommentRequest provides a mock function with given fields: _a0
func (_m *Route53Client) UpdateTrafficPolicyCommentRequest(_a0 *route53.UpdateTrafficPolicyCommentInput) (*request.Request, *route53.UpdateTrafficPolicyCommentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.UpdateTrafficPolicyCommentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.UpdateTrafficPolicyCommentOutput
	if rf, ok := ret.Get(1).(func(*route53.UpdateTrafficPolicyCommentInput) *route53.UpdateTrafficPolicyCommentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.UpdateTrafficPolicyCommentOutput)
		}
	}

	return r0, r1
}

// UpdateTrafficPolicyCommentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) UpdateTrafficPolicyCommentWithContext(_a0 context.Context, _a1 *route53.UpdateTrafficPolicyCommentInput, _a2 ...request.Option) (*route53.UpdateTrafficPolicyCommentOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.UpdateTrafficPolicyCommentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.UpdateTrafficPolicyCommentInput, ...request.Option) *route53.UpdateTrafficPolicyCommentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.UpdateTrafficPolicyCommentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.UpdateTrafficPolicyCommentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrafficPolicyInstance provides a mock function with given fields: _a0
func (_m *Route53Client) UpdateTrafficPolicyInstance(_a0 *route53.UpdateTrafficPolicyInstanceInput) (*route53.UpdateTrafficPolicyInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *route53.UpdateTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(0).(func(*route53.UpdateTrafficPolicyInstanceInput) *route53.UpdateTrafficPolicyInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.UpdateTrafficPolicyInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*route53.UpdateTrafficPolicyInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTrafficPolicyInstanceRequest provides a mock function with given fields: _a0
func (_m *Route53Client) UpdateTrafficPolicyInstanceRequest(_a0 *route53.UpdateTrafficPolicyInstanceInput) (*request.Request, *route53.UpdateTrafficPolicyInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*route53.UpdateTrafficPolicyInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *route53.UpdateTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(1).(func(*route53.UpdateTrafficPolicyInstanceInput) *route53.UpdateTrafficPolicyInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*route53.UpdateTrafficPolicyInstanceOutput)
		}
	}

	return r0, r1
}

// UpdateTrafficPolicyInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) UpdateTrafficPolicyInstanceWithContext(_a0 context.Context, _a1 *route53.UpdateTrafficPolicyInstanceInput, _a2 ...request.Option) (*route53.UpdateTrafficPolicyInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *route53.UpdateTrafficPolicyInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *route53.UpdateTrafficPolicyInstanceInput, ...request.Option) *route53.UpdateTrafficPolicyInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*route53.UpdateTrafficPolicyInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *route53.UpdateTrafficPolicyInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilResourceRecordSetsChanged provides a mock function with given fields: _a0
func (_m *Route53Client) WaitUntilResourceRecordSetsChanged(_a0 *route53.GetChangeInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*route53.GetChangeInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilResourceRecordSetsChangedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *Route53Client) WaitUntilResourceRecordSetsChangedWithContext(_a0 context.Context, _a1 *route53.GetChangeInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *route53.GetChangeInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}