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

package aws

import (
	context "context"

	ec2 "github.com/aws/aws-sdk-go/service/ec2"
	mock "github.com/stretchr/testify/mock"

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

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

// AcceptReservedInstancesExchangeQuote provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptReservedInstancesExchangeQuote(_a0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AcceptReservedInstancesExchangeQuoteOutput
	if rf, ok := ret.Get(0).(func(*ec2.AcceptReservedInstancesExchangeQuoteInput) *ec2.AcceptReservedInstancesExchangeQuoteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
		}
	}

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

	return r0, r1
}

// AcceptReservedInstancesExchangeQuoteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptReservedInstancesExchangeQuoteRequest(_a0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.AcceptReservedInstancesExchangeQuoteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AcceptReservedInstancesExchangeQuoteOutput
	if rf, ok := ret.Get(1).(func(*ec2.AcceptReservedInstancesExchangeQuoteInput) *ec2.AcceptReservedInstancesExchangeQuoteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
		}
	}

	return r0, r1
}

// AcceptReservedInstancesExchangeQuoteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AcceptReservedInstancesExchangeQuoteWithContext(_a0 context.Context, _a1 *ec2.AcceptReservedInstancesExchangeQuoteInput, _a2 ...request.Option) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, 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 *ec2.AcceptReservedInstancesExchangeQuoteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptReservedInstancesExchangeQuoteInput, ...request.Option) *ec2.AcceptReservedInstancesExchangeQuoteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
		}
	}

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

	return r0, r1
}

// AcceptTransitGatewayMulticastDomainAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptTransitGatewayMulticastDomainAssociations(_a0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

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

	return r0, r1
}

// AcceptTransitGatewayMulticastDomainAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptTransitGatewayMulticastDomainAssociationsRequest(_a0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	return r0, r1
}

// AcceptTransitGatewayMulticastDomainAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AcceptTransitGatewayMulticastDomainAssociationsWithContext(_a0 context.Context, _a1 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, _a2 ...request.Option) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, 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 *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, ...request.Option) *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

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

	return r0, r1
}

// AcceptTransitGatewayPeeringAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptTransitGatewayPeeringAttachment(_a0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AcceptTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.AcceptTransitGatewayPeeringAttachmentInput) *ec2.AcceptTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
		}
	}

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

	return r0, r1
}

// AcceptTransitGatewayPeeringAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptTransitGatewayPeeringAttachmentRequest(_a0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayPeeringAttachmentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AcceptTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.AcceptTransitGatewayPeeringAttachmentInput) *ec2.AcceptTransitGatewayPeeringAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
		}
	}

	return r0, r1
}

// AcceptTransitGatewayPeeringAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AcceptTransitGatewayPeeringAttachmentWithContext(_a0 context.Context, _a1 *ec2.AcceptTransitGatewayPeeringAttachmentInput, _a2 ...request.Option) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, 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 *ec2.AcceptTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayPeeringAttachmentInput, ...request.Option) *ec2.AcceptTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
		}
	}

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

	return r0, r1
}

// AcceptTransitGatewayVpcAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptTransitGatewayVpcAttachment(_a0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AcceptTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.AcceptTransitGatewayVpcAttachmentInput) *ec2.AcceptTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
		}
	}

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

	return r0, r1
}

// AcceptTransitGatewayVpcAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptTransitGatewayVpcAttachmentRequest(_a0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayVpcAttachmentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AcceptTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.AcceptTransitGatewayVpcAttachmentInput) *ec2.AcceptTransitGatewayVpcAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
		}
	}

	return r0, r1
}

// AcceptTransitGatewayVpcAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AcceptTransitGatewayVpcAttachmentWithContext(_a0 context.Context, _a1 *ec2.AcceptTransitGatewayVpcAttachmentInput, _a2 ...request.Option) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, 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 *ec2.AcceptTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayVpcAttachmentInput, ...request.Option) *ec2.AcceptTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
		}
	}

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

	return r0, r1
}

// AcceptVpcEndpointConnections provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptVpcEndpointConnections(_a0 *ec2.AcceptVpcEndpointConnectionsInput) (*ec2.AcceptVpcEndpointConnectionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AcceptVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.AcceptVpcEndpointConnectionsInput) *ec2.AcceptVpcEndpointConnectionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptVpcEndpointConnectionsOutput)
		}
	}

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

	return r0, r1
}

// AcceptVpcEndpointConnectionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptVpcEndpointConnectionsRequest(_a0 *ec2.AcceptVpcEndpointConnectionsInput) (*request.Request, *ec2.AcceptVpcEndpointConnectionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AcceptVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.AcceptVpcEndpointConnectionsInput) *ec2.AcceptVpcEndpointConnectionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AcceptVpcEndpointConnectionsOutput)
		}
	}

	return r0, r1
}

// AcceptVpcEndpointConnectionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AcceptVpcEndpointConnectionsWithContext(_a0 context.Context, _a1 *ec2.AcceptVpcEndpointConnectionsInput, _a2 ...request.Option) (*ec2.AcceptVpcEndpointConnectionsOutput, 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 *ec2.AcceptVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptVpcEndpointConnectionsInput, ...request.Option) *ec2.AcceptVpcEndpointConnectionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptVpcEndpointConnectionsOutput)
		}
	}

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

	return r0, r1
}

// AcceptVpcPeeringConnection provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptVpcPeeringConnection(_a0 *ec2.AcceptVpcPeeringConnectionInput) (*ec2.AcceptVpcPeeringConnectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AcceptVpcPeeringConnectionOutput
	if rf, ok := ret.Get(0).(func(*ec2.AcceptVpcPeeringConnectionInput) *ec2.AcceptVpcPeeringConnectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptVpcPeeringConnectionOutput)
		}
	}

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

	return r0, r1
}

// AcceptVpcPeeringConnectionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AcceptVpcPeeringConnectionRequest(_a0 *ec2.AcceptVpcPeeringConnectionInput) (*request.Request, *ec2.AcceptVpcPeeringConnectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AcceptVpcPeeringConnectionOutput
	if rf, ok := ret.Get(1).(func(*ec2.AcceptVpcPeeringConnectionInput) *ec2.AcceptVpcPeeringConnectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AcceptVpcPeeringConnectionOutput)
		}
	}

	return r0, r1
}

// AcceptVpcPeeringConnectionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AcceptVpcPeeringConnectionWithContext(_a0 context.Context, _a1 *ec2.AcceptVpcPeeringConnectionInput, _a2 ...request.Option) (*ec2.AcceptVpcPeeringConnectionOutput, 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 *ec2.AcceptVpcPeeringConnectionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptVpcPeeringConnectionInput, ...request.Option) *ec2.AcceptVpcPeeringConnectionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptVpcPeeringConnectionOutput)
		}
	}

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

	return r0, r1
}

// AdvertiseByoipCidr provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AdvertiseByoipCidr(_a0 *ec2.AdvertiseByoipCidrInput) (*ec2.AdvertiseByoipCidrOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AdvertiseByoipCidrOutput
	if rf, ok := ret.Get(0).(func(*ec2.AdvertiseByoipCidrInput) *ec2.AdvertiseByoipCidrOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AdvertiseByoipCidrOutput)
		}
	}

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

	return r0, r1
}

// AdvertiseByoipCidrRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AdvertiseByoipCidrRequest(_a0 *ec2.AdvertiseByoipCidrInput) (*request.Request, *ec2.AdvertiseByoipCidrOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AdvertiseByoipCidrOutput
	if rf, ok := ret.Get(1).(func(*ec2.AdvertiseByoipCidrInput) *ec2.AdvertiseByoipCidrOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AdvertiseByoipCidrOutput)
		}
	}

	return r0, r1
}

// AdvertiseByoipCidrWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AdvertiseByoipCidrWithContext(_a0 context.Context, _a1 *ec2.AdvertiseByoipCidrInput, _a2 ...request.Option) (*ec2.AdvertiseByoipCidrOutput, 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 *ec2.AdvertiseByoipCidrOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AdvertiseByoipCidrInput, ...request.Option) *ec2.AdvertiseByoipCidrOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AdvertiseByoipCidrOutput)
		}
	}

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

	return r0, r1
}

// AllocateAddress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AllocateAddress(_a0 *ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AllocateAddressOutput
	if rf, ok := ret.Get(0).(func(*ec2.AllocateAddressInput) *ec2.AllocateAddressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AllocateAddressOutput)
		}
	}

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

	return r0, r1
}

// AllocateAddressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AllocateAddressRequest(_a0 *ec2.AllocateAddressInput) (*request.Request, *ec2.AllocateAddressOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AllocateAddressOutput
	if rf, ok := ret.Get(1).(func(*ec2.AllocateAddressInput) *ec2.AllocateAddressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AllocateAddressOutput)
		}
	}

	return r0, r1
}

// AllocateAddressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AllocateAddressWithContext(_a0 context.Context, _a1 *ec2.AllocateAddressInput, _a2 ...request.Option) (*ec2.AllocateAddressOutput, 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 *ec2.AllocateAddressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AllocateAddressInput, ...request.Option) *ec2.AllocateAddressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AllocateAddressOutput)
		}
	}

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

	return r0, r1
}

// AllocateHosts provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AllocateHosts(_a0 *ec2.AllocateHostsInput) (*ec2.AllocateHostsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AllocateHostsOutput
	if rf, ok := ret.Get(0).(func(*ec2.AllocateHostsInput) *ec2.AllocateHostsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AllocateHostsOutput)
		}
	}

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

	return r0, r1
}

// AllocateHostsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AllocateHostsRequest(_a0 *ec2.AllocateHostsInput) (*request.Request, *ec2.AllocateHostsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AllocateHostsOutput
	if rf, ok := ret.Get(1).(func(*ec2.AllocateHostsInput) *ec2.AllocateHostsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AllocateHostsOutput)
		}
	}

	return r0, r1
}

// AllocateHostsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AllocateHostsWithContext(_a0 context.Context, _a1 *ec2.AllocateHostsInput, _a2 ...request.Option) (*ec2.AllocateHostsOutput, 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 *ec2.AllocateHostsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AllocateHostsInput, ...request.Option) *ec2.AllocateHostsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AllocateHostsOutput)
		}
	}

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

	return r0, r1
}

// ApplySecurityGroupsToClientVpnTargetNetwork provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ApplySecurityGroupsToClientVpnTargetNetwork(_a0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(0).(func(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
		}
	}

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

	return r0, r1
}

// ApplySecurityGroupsToClientVpnTargetNetworkRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ApplySecurityGroupsToClientVpnTargetNetworkRequest(_a0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*request.Request, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(1).(func(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
		}
	}

	return r0, r1
}

// ApplySecurityGroupsToClientVpnTargetNetworkWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(_a0 context.Context, _a1 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, _a2 ...request.Option) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, 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 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, ...request.Option) *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
		}
	}

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

	return r0, r1
}

// AssignIpv6Addresses provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssignIpv6Addresses(_a0 *ec2.AssignIpv6AddressesInput) (*ec2.AssignIpv6AddressesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssignIpv6AddressesOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssignIpv6AddressesInput) *ec2.AssignIpv6AddressesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssignIpv6AddressesOutput)
		}
	}

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

	return r0, r1
}

// AssignIpv6AddressesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssignIpv6AddressesRequest(_a0 *ec2.AssignIpv6AddressesInput) (*request.Request, *ec2.AssignIpv6AddressesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssignIpv6AddressesOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssignIpv6AddressesInput) *ec2.AssignIpv6AddressesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssignIpv6AddressesOutput)
		}
	}

	return r0, r1
}

// AssignIpv6AddressesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssignIpv6AddressesWithContext(_a0 context.Context, _a1 *ec2.AssignIpv6AddressesInput, _a2 ...request.Option) (*ec2.AssignIpv6AddressesOutput, 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 *ec2.AssignIpv6AddressesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssignIpv6AddressesInput, ...request.Option) *ec2.AssignIpv6AddressesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssignIpv6AddressesOutput)
		}
	}

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

	return r0, r1
}

// AssignPrivateIpAddresses provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssignPrivateIpAddresses(_a0 *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssignPrivateIpAddressesOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssignPrivateIpAddressesInput) *ec2.AssignPrivateIpAddressesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssignPrivateIpAddressesOutput)
		}
	}

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

	return r0, r1
}

// AssignPrivateIpAddressesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssignPrivateIpAddressesRequest(_a0 *ec2.AssignPrivateIpAddressesInput) (*request.Request, *ec2.AssignPrivateIpAddressesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssignPrivateIpAddressesOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssignPrivateIpAddressesInput) *ec2.AssignPrivateIpAddressesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssignPrivateIpAddressesOutput)
		}
	}

	return r0, r1
}

// AssignPrivateIpAddressesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssignPrivateIpAddressesWithContext(_a0 context.Context, _a1 *ec2.AssignPrivateIpAddressesInput, _a2 ...request.Option) (*ec2.AssignPrivateIpAddressesOutput, 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 *ec2.AssignPrivateIpAddressesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssignPrivateIpAddressesInput, ...request.Option) *ec2.AssignPrivateIpAddressesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssignPrivateIpAddressesOutput)
		}
	}

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

	return r0, r1
}

// AssociateAddress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateAddress(_a0 *ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateAddressOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateAddressInput) *ec2.AssociateAddressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateAddressOutput)
		}
	}

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

	return r0, r1
}

// AssociateAddressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateAddressRequest(_a0 *ec2.AssociateAddressInput) (*request.Request, *ec2.AssociateAddressOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateAddressOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateAddressInput) *ec2.AssociateAddressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateAddressOutput)
		}
	}

	return r0, r1
}

// AssociateAddressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateAddressWithContext(_a0 context.Context, _a1 *ec2.AssociateAddressInput, _a2 ...request.Option) (*ec2.AssociateAddressOutput, 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 *ec2.AssociateAddressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateAddressInput, ...request.Option) *ec2.AssociateAddressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateAddressOutput)
		}
	}

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

	return r0, r1
}

// AssociateClientVpnTargetNetwork provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateClientVpnTargetNetwork(_a0 *ec2.AssociateClientVpnTargetNetworkInput) (*ec2.AssociateClientVpnTargetNetworkOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateClientVpnTargetNetworkInput) *ec2.AssociateClientVpnTargetNetworkOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateClientVpnTargetNetworkOutput)
		}
	}

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

	return r0, r1
}

// AssociateClientVpnTargetNetworkRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateClientVpnTargetNetworkRequest(_a0 *ec2.AssociateClientVpnTargetNetworkInput) (*request.Request, *ec2.AssociateClientVpnTargetNetworkOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateClientVpnTargetNetworkInput) *ec2.AssociateClientVpnTargetNetworkOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateClientVpnTargetNetworkOutput)
		}
	}

	return r0, r1
}

// AssociateClientVpnTargetNetworkWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateClientVpnTargetNetworkWithContext(_a0 context.Context, _a1 *ec2.AssociateClientVpnTargetNetworkInput, _a2 ...request.Option) (*ec2.AssociateClientVpnTargetNetworkOutput, 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 *ec2.AssociateClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateClientVpnTargetNetworkInput, ...request.Option) *ec2.AssociateClientVpnTargetNetworkOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateClientVpnTargetNetworkOutput)
		}
	}

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

	return r0, r1
}

// AssociateDhcpOptions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateDhcpOptions(_a0 *ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateDhcpOptionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateDhcpOptionsInput) *ec2.AssociateDhcpOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateDhcpOptionsOutput)
		}
	}

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

	return r0, r1
}

// AssociateDhcpOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateDhcpOptionsRequest(_a0 *ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateDhcpOptionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateDhcpOptionsInput) *ec2.AssociateDhcpOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateDhcpOptionsOutput)
		}
	}

	return r0, r1
}

// AssociateDhcpOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateDhcpOptionsWithContext(_a0 context.Context, _a1 *ec2.AssociateDhcpOptionsInput, _a2 ...request.Option) (*ec2.AssociateDhcpOptionsOutput, 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 *ec2.AssociateDhcpOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateDhcpOptionsInput, ...request.Option) *ec2.AssociateDhcpOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateDhcpOptionsOutput)
		}
	}

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

	return r0, r1
}

// AssociateEnclaveCertificateIamRole provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateEnclaveCertificateIamRole(_a0 *ec2.AssociateEnclaveCertificateIamRoleInput) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateEnclaveCertificateIamRoleOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateEnclaveCertificateIamRoleInput) *ec2.AssociateEnclaveCertificateIamRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateEnclaveCertificateIamRoleOutput)
		}
	}

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

	return r0, r1
}

// AssociateEnclaveCertificateIamRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateEnclaveCertificateIamRoleRequest(_a0 *ec2.AssociateEnclaveCertificateIamRoleInput) (*request.Request, *ec2.AssociateEnclaveCertificateIamRoleOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateEnclaveCertificateIamRoleOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateEnclaveCertificateIamRoleInput) *ec2.AssociateEnclaveCertificateIamRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateEnclaveCertificateIamRoleOutput)
		}
	}

	return r0, r1
}

// AssociateEnclaveCertificateIamRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateEnclaveCertificateIamRoleWithContext(_a0 context.Context, _a1 *ec2.AssociateEnclaveCertificateIamRoleInput, _a2 ...request.Option) (*ec2.AssociateEnclaveCertificateIamRoleOutput, 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 *ec2.AssociateEnclaveCertificateIamRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateEnclaveCertificateIamRoleInput, ...request.Option) *ec2.AssociateEnclaveCertificateIamRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateEnclaveCertificateIamRoleOutput)
		}
	}

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

	return r0, r1
}

// AssociateIamInstanceProfile provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateIamInstanceProfile(_a0 *ec2.AssociateIamInstanceProfileInput) (*ec2.AssociateIamInstanceProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateIamInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateIamInstanceProfileInput) *ec2.AssociateIamInstanceProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateIamInstanceProfileOutput)
		}
	}

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

	return r0, r1
}

// AssociateIamInstanceProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateIamInstanceProfileRequest(_a0 *ec2.AssociateIamInstanceProfileInput) (*request.Request, *ec2.AssociateIamInstanceProfileOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateIamInstanceProfileOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateIamInstanceProfileInput) *ec2.AssociateIamInstanceProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateIamInstanceProfileOutput)
		}
	}

	return r0, r1
}

// AssociateIamInstanceProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateIamInstanceProfileWithContext(_a0 context.Context, _a1 *ec2.AssociateIamInstanceProfileInput, _a2 ...request.Option) (*ec2.AssociateIamInstanceProfileOutput, 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 *ec2.AssociateIamInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateIamInstanceProfileInput, ...request.Option) *ec2.AssociateIamInstanceProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateIamInstanceProfileOutput)
		}
	}

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

	return r0, r1
}

// AssociateRouteTable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateRouteTable(_a0 *ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateRouteTableOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateRouteTableInput) *ec2.AssociateRouteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateRouteTableOutput)
		}
	}

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

	return r0, r1
}

// AssociateRouteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateRouteTableRequest(_a0 *ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateRouteTableOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateRouteTableInput) *ec2.AssociateRouteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateRouteTableOutput)
		}
	}

	return r0, r1
}

// AssociateRouteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateRouteTableWithContext(_a0 context.Context, _a1 *ec2.AssociateRouteTableInput, _a2 ...request.Option) (*ec2.AssociateRouteTableOutput, 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 *ec2.AssociateRouteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateRouteTableInput, ...request.Option) *ec2.AssociateRouteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateRouteTableOutput)
		}
	}

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

	return r0, r1
}

// AssociateSubnetCidrBlock provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateSubnetCidrBlock(_a0 *ec2.AssociateSubnetCidrBlockInput) (*ec2.AssociateSubnetCidrBlockOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateSubnetCidrBlockOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateSubnetCidrBlockInput) *ec2.AssociateSubnetCidrBlockOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateSubnetCidrBlockOutput)
		}
	}

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

	return r0, r1
}

// AssociateSubnetCidrBlockRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateSubnetCidrBlockRequest(_a0 *ec2.AssociateSubnetCidrBlockInput) (*request.Request, *ec2.AssociateSubnetCidrBlockOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateSubnetCidrBlockOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateSubnetCidrBlockInput) *ec2.AssociateSubnetCidrBlockOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateSubnetCidrBlockOutput)
		}
	}

	return r0, r1
}

// AssociateSubnetCidrBlockWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateSubnetCidrBlockWithContext(_a0 context.Context, _a1 *ec2.AssociateSubnetCidrBlockInput, _a2 ...request.Option) (*ec2.AssociateSubnetCidrBlockOutput, 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 *ec2.AssociateSubnetCidrBlockOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateSubnetCidrBlockInput, ...request.Option) *ec2.AssociateSubnetCidrBlockOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateSubnetCidrBlockOutput)
		}
	}

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

	return r0, r1
}

// AssociateTransitGatewayMulticastDomain provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateTransitGatewayMulticastDomain(_a0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateTransitGatewayMulticastDomainInput) *ec2.AssociateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTransitGatewayMulticastDomainOutput)
		}
	}

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

	return r0, r1
}

// AssociateTransitGatewayMulticastDomainRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateTransitGatewayMulticastDomainRequest(_a0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.AssociateTransitGatewayMulticastDomainOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateTransitGatewayMulticastDomainInput) *ec2.AssociateTransitGatewayMulticastDomainOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateTransitGatewayMulticastDomainOutput)
		}
	}

	return r0, r1
}

// AssociateTransitGatewayMulticastDomainWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateTransitGatewayMulticastDomainWithContext(_a0 context.Context, _a1 *ec2.AssociateTransitGatewayMulticastDomainInput, _a2 ...request.Option) (*ec2.AssociateTransitGatewayMulticastDomainOutput, 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 *ec2.AssociateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTransitGatewayMulticastDomainInput, ...request.Option) *ec2.AssociateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTransitGatewayMulticastDomainOutput)
		}
	}

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

	return r0, r1
}

// AssociateTransitGatewayRouteTable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateTransitGatewayRouteTable(_a0 *ec2.AssociateTransitGatewayRouteTableInput) (*ec2.AssociateTransitGatewayRouteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateTransitGatewayRouteTableInput) *ec2.AssociateTransitGatewayRouteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTransitGatewayRouteTableOutput)
		}
	}

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

	return r0, r1
}

// AssociateTransitGatewayRouteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateTransitGatewayRouteTableRequest(_a0 *ec2.AssociateTransitGatewayRouteTableInput) (*request.Request, *ec2.AssociateTransitGatewayRouteTableOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateTransitGatewayRouteTableInput) *ec2.AssociateTransitGatewayRouteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateTransitGatewayRouteTableOutput)
		}
	}

	return r0, r1
}

// AssociateTransitGatewayRouteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateTransitGatewayRouteTableWithContext(_a0 context.Context, _a1 *ec2.AssociateTransitGatewayRouteTableInput, _a2 ...request.Option) (*ec2.AssociateTransitGatewayRouteTableOutput, 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 *ec2.AssociateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTransitGatewayRouteTableInput, ...request.Option) *ec2.AssociateTransitGatewayRouteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTransitGatewayRouteTableOutput)
		}
	}

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

	return r0, r1
}

// AssociateTrunkInterface provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateTrunkInterface(_a0 *ec2.AssociateTrunkInterfaceInput) (*ec2.AssociateTrunkInterfaceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateTrunkInterfaceOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateTrunkInterfaceInput) *ec2.AssociateTrunkInterfaceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTrunkInterfaceOutput)
		}
	}

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

	return r0, r1
}

// AssociateTrunkInterfaceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateTrunkInterfaceRequest(_a0 *ec2.AssociateTrunkInterfaceInput) (*request.Request, *ec2.AssociateTrunkInterfaceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateTrunkInterfaceOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateTrunkInterfaceInput) *ec2.AssociateTrunkInterfaceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateTrunkInterfaceOutput)
		}
	}

	return r0, r1
}

// AssociateTrunkInterfaceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateTrunkInterfaceWithContext(_a0 context.Context, _a1 *ec2.AssociateTrunkInterfaceInput, _a2 ...request.Option) (*ec2.AssociateTrunkInterfaceOutput, 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 *ec2.AssociateTrunkInterfaceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTrunkInterfaceInput, ...request.Option) *ec2.AssociateTrunkInterfaceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTrunkInterfaceOutput)
		}
	}

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

	return r0, r1
}

// AssociateVpcCidrBlock provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateVpcCidrBlock(_a0 *ec2.AssociateVpcCidrBlockInput) (*ec2.AssociateVpcCidrBlockOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AssociateVpcCidrBlockOutput
	if rf, ok := ret.Get(0).(func(*ec2.AssociateVpcCidrBlockInput) *ec2.AssociateVpcCidrBlockOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateVpcCidrBlockOutput)
		}
	}

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

	return r0, r1
}

// AssociateVpcCidrBlockRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AssociateVpcCidrBlockRequest(_a0 *ec2.AssociateVpcCidrBlockInput) (*request.Request, *ec2.AssociateVpcCidrBlockOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AssociateVpcCidrBlockOutput
	if rf, ok := ret.Get(1).(func(*ec2.AssociateVpcCidrBlockInput) *ec2.AssociateVpcCidrBlockOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AssociateVpcCidrBlockOutput)
		}
	}

	return r0, r1
}

// AssociateVpcCidrBlockWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AssociateVpcCidrBlockWithContext(_a0 context.Context, _a1 *ec2.AssociateVpcCidrBlockInput, _a2 ...request.Option) (*ec2.AssociateVpcCidrBlockOutput, 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 *ec2.AssociateVpcCidrBlockOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateVpcCidrBlockInput, ...request.Option) *ec2.AssociateVpcCidrBlockOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateVpcCidrBlockOutput)
		}
	}

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

	return r0, r1
}

// AttachClassicLinkVpc provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachClassicLinkVpc(_a0 *ec2.AttachClassicLinkVpcInput) (*ec2.AttachClassicLinkVpcOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AttachClassicLinkVpcOutput
	if rf, ok := ret.Get(0).(func(*ec2.AttachClassicLinkVpcInput) *ec2.AttachClassicLinkVpcOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachClassicLinkVpcOutput)
		}
	}

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

	return r0, r1
}

// AttachClassicLinkVpcRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachClassicLinkVpcRequest(_a0 *ec2.AttachClassicLinkVpcInput) (*request.Request, *ec2.AttachClassicLinkVpcOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AttachClassicLinkVpcOutput
	if rf, ok := ret.Get(1).(func(*ec2.AttachClassicLinkVpcInput) *ec2.AttachClassicLinkVpcOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AttachClassicLinkVpcOutput)
		}
	}

	return r0, r1
}

// AttachClassicLinkVpcWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AttachClassicLinkVpcWithContext(_a0 context.Context, _a1 *ec2.AttachClassicLinkVpcInput, _a2 ...request.Option) (*ec2.AttachClassicLinkVpcOutput, 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 *ec2.AttachClassicLinkVpcOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachClassicLinkVpcInput, ...request.Option) *ec2.AttachClassicLinkVpcOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachClassicLinkVpcOutput)
		}
	}

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

	return r0, r1
}

// AttachInternetGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachInternetGateway(_a0 *ec2.AttachInternetGatewayInput) (*ec2.AttachInternetGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AttachInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.AttachInternetGatewayInput) *ec2.AttachInternetGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// AttachInternetGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachInternetGatewayRequest(_a0 *ec2.AttachInternetGatewayInput) (*request.Request, *ec2.AttachInternetGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AttachInternetGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.AttachInternetGatewayInput) *ec2.AttachInternetGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AttachInternetGatewayOutput)
		}
	}

	return r0, r1
}

// AttachInternetGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AttachInternetGatewayWithContext(_a0 context.Context, _a1 *ec2.AttachInternetGatewayInput, _a2 ...request.Option) (*ec2.AttachInternetGatewayOutput, 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 *ec2.AttachInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachInternetGatewayInput, ...request.Option) *ec2.AttachInternetGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// AttachNetworkInterface provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachNetworkInterface(_a0 *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AttachNetworkInterfaceOutput
	if rf, ok := ret.Get(0).(func(*ec2.AttachNetworkInterfaceInput) *ec2.AttachNetworkInterfaceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachNetworkInterfaceOutput)
		}
	}

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

	return r0, r1
}

// AttachNetworkInterfaceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachNetworkInterfaceRequest(_a0 *ec2.AttachNetworkInterfaceInput) (*request.Request, *ec2.AttachNetworkInterfaceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AttachNetworkInterfaceOutput
	if rf, ok := ret.Get(1).(func(*ec2.AttachNetworkInterfaceInput) *ec2.AttachNetworkInterfaceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AttachNetworkInterfaceOutput)
		}
	}

	return r0, r1
}

// AttachNetworkInterfaceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AttachNetworkInterfaceWithContext(_a0 context.Context, _a1 *ec2.AttachNetworkInterfaceInput, _a2 ...request.Option) (*ec2.AttachNetworkInterfaceOutput, 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 *ec2.AttachNetworkInterfaceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachNetworkInterfaceInput, ...request.Option) *ec2.AttachNetworkInterfaceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachNetworkInterfaceOutput)
		}
	}

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

	return r0, r1
}

// AttachVolume provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachVolume(_a0 *ec2.AttachVolumeInput) (*ec2.VolumeAttachment, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.VolumeAttachment
	if rf, ok := ret.Get(0).(func(*ec2.AttachVolumeInput) *ec2.VolumeAttachment); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.VolumeAttachment)
		}
	}

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

	return r0, r1
}

// AttachVolumeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachVolumeRequest(_a0 *ec2.AttachVolumeInput) (*request.Request, *ec2.VolumeAttachment) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.VolumeAttachment
	if rf, ok := ret.Get(1).(func(*ec2.AttachVolumeInput) *ec2.VolumeAttachment); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.VolumeAttachment)
		}
	}

	return r0, r1
}

// AttachVolumeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AttachVolumeWithContext(_a0 context.Context, _a1 *ec2.AttachVolumeInput, _a2 ...request.Option) (*ec2.VolumeAttachment, 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 *ec2.VolumeAttachment
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachVolumeInput, ...request.Option) *ec2.VolumeAttachment); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.VolumeAttachment)
		}
	}

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

	return r0, r1
}

// AttachVpnGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachVpnGateway(_a0 *ec2.AttachVpnGatewayInput) (*ec2.AttachVpnGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AttachVpnGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.AttachVpnGatewayInput) *ec2.AttachVpnGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachVpnGatewayOutput)
		}
	}

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

	return r0, r1
}

// AttachVpnGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AttachVpnGatewayRequest(_a0 *ec2.AttachVpnGatewayInput) (*request.Request, *ec2.AttachVpnGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AttachVpnGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.AttachVpnGatewayInput) *ec2.AttachVpnGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AttachVpnGatewayOutput)
		}
	}

	return r0, r1
}

// AttachVpnGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AttachVpnGatewayWithContext(_a0 context.Context, _a1 *ec2.AttachVpnGatewayInput, _a2 ...request.Option) (*ec2.AttachVpnGatewayOutput, 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 *ec2.AttachVpnGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachVpnGatewayInput, ...request.Option) *ec2.AttachVpnGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachVpnGatewayOutput)
		}
	}

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

	return r0, r1
}

// AuthorizeClientVpnIngress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AuthorizeClientVpnIngress(_a0 *ec2.AuthorizeClientVpnIngressInput) (*ec2.AuthorizeClientVpnIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AuthorizeClientVpnIngressOutput
	if rf, ok := ret.Get(0).(func(*ec2.AuthorizeClientVpnIngressInput) *ec2.AuthorizeClientVpnIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeClientVpnIngressOutput)
		}
	}

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

	return r0, r1
}

// AuthorizeClientVpnIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AuthorizeClientVpnIngressRequest(_a0 *ec2.AuthorizeClientVpnIngressInput) (*request.Request, *ec2.AuthorizeClientVpnIngressOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AuthorizeClientVpnIngressOutput
	if rf, ok := ret.Get(1).(func(*ec2.AuthorizeClientVpnIngressInput) *ec2.AuthorizeClientVpnIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AuthorizeClientVpnIngressOutput)
		}
	}

	return r0, r1
}

// AuthorizeClientVpnIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AuthorizeClientVpnIngressWithContext(_a0 context.Context, _a1 *ec2.AuthorizeClientVpnIngressInput, _a2 ...request.Option) (*ec2.AuthorizeClientVpnIngressOutput, 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 *ec2.AuthorizeClientVpnIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeClientVpnIngressInput, ...request.Option) *ec2.AuthorizeClientVpnIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeClientVpnIngressOutput)
		}
	}

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

	return r0, r1
}

// AuthorizeSecurityGroupEgress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AuthorizeSecurityGroupEgress(_a0 *ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AuthorizeSecurityGroupEgressOutput
	if rf, ok := ret.Get(0).(func(*ec2.AuthorizeSecurityGroupEgressInput) *ec2.AuthorizeSecurityGroupEgressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeSecurityGroupEgressOutput)
		}
	}

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

	return r0, r1
}

// AuthorizeSecurityGroupEgressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AuthorizeSecurityGroupEgressRequest(_a0 *ec2.AuthorizeSecurityGroupEgressInput) (*request.Request, *ec2.AuthorizeSecurityGroupEgressOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AuthorizeSecurityGroupEgressOutput
	if rf, ok := ret.Get(1).(func(*ec2.AuthorizeSecurityGroupEgressInput) *ec2.AuthorizeSecurityGroupEgressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AuthorizeSecurityGroupEgressOutput)
		}
	}

	return r0, r1
}

// AuthorizeSecurityGroupEgressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AuthorizeSecurityGroupEgressWithContext(_a0 context.Context, _a1 *ec2.AuthorizeSecurityGroupEgressInput, _a2 ...request.Option) (*ec2.AuthorizeSecurityGroupEgressOutput, 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 *ec2.AuthorizeSecurityGroupEgressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeSecurityGroupEgressInput, ...request.Option) *ec2.AuthorizeSecurityGroupEgressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeSecurityGroupEgressOutput)
		}
	}

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

	return r0, r1
}

// AuthorizeSecurityGroupIngress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AuthorizeSecurityGroupIngress(_a0 *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.AuthorizeSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(*ec2.AuthorizeSecurityGroupIngressInput) *ec2.AuthorizeSecurityGroupIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeSecurityGroupIngressOutput)
		}
	}

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

	return r0, r1
}

// AuthorizeSecurityGroupIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) AuthorizeSecurityGroupIngressRequest(_a0 *ec2.AuthorizeSecurityGroupIngressInput) (*request.Request, *ec2.AuthorizeSecurityGroupIngressOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.AuthorizeSecurityGroupIngressOutput
	if rf, ok := ret.Get(1).(func(*ec2.AuthorizeSecurityGroupIngressInput) *ec2.AuthorizeSecurityGroupIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.AuthorizeSecurityGroupIngressOutput)
		}
	}

	return r0, r1
}

// AuthorizeSecurityGroupIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) AuthorizeSecurityGroupIngressWithContext(_a0 context.Context, _a1 *ec2.AuthorizeSecurityGroupIngressInput, _a2 ...request.Option) (*ec2.AuthorizeSecurityGroupIngressOutput, 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 *ec2.AuthorizeSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeSecurityGroupIngressInput, ...request.Option) *ec2.AuthorizeSecurityGroupIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeSecurityGroupIngressOutput)
		}
	}

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

	return r0, r1
}

// BundleInstance provides a mock function with given fields: _a0
func (_m *MockFakeEC2) BundleInstance(_a0 *ec2.BundleInstanceInput) (*ec2.BundleInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.BundleInstanceOutput
	if rf, ok := ret.Get(0).(func(*ec2.BundleInstanceInput) *ec2.BundleInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.BundleInstanceOutput)
		}
	}

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

	return r0, r1
}

// BundleInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) BundleInstanceRequest(_a0 *ec2.BundleInstanceInput) (*request.Request, *ec2.BundleInstanceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.BundleInstanceOutput
	if rf, ok := ret.Get(1).(func(*ec2.BundleInstanceInput) *ec2.BundleInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.BundleInstanceOutput)
		}
	}

	return r0, r1
}

// BundleInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) BundleInstanceWithContext(_a0 context.Context, _a1 *ec2.BundleInstanceInput, _a2 ...request.Option) (*ec2.BundleInstanceOutput, 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 *ec2.BundleInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.BundleInstanceInput, ...request.Option) *ec2.BundleInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.BundleInstanceOutput)
		}
	}

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

	return r0, r1
}

// CancelBundleTask provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelBundleTask(_a0 *ec2.CancelBundleTaskInput) (*ec2.CancelBundleTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CancelBundleTaskOutput
	if rf, ok := ret.Get(0).(func(*ec2.CancelBundleTaskInput) *ec2.CancelBundleTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelBundleTaskOutput)
		}
	}

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

	return r0, r1
}

// CancelBundleTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelBundleTaskRequest(_a0 *ec2.CancelBundleTaskInput) (*request.Request, *ec2.CancelBundleTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CancelBundleTaskOutput
	if rf, ok := ret.Get(1).(func(*ec2.CancelBundleTaskInput) *ec2.CancelBundleTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CancelBundleTaskOutput)
		}
	}

	return r0, r1
}

// CancelBundleTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CancelBundleTaskWithContext(_a0 context.Context, _a1 *ec2.CancelBundleTaskInput, _a2 ...request.Option) (*ec2.CancelBundleTaskOutput, 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 *ec2.CancelBundleTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelBundleTaskInput, ...request.Option) *ec2.CancelBundleTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelBundleTaskOutput)
		}
	}

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

	return r0, r1
}

// CancelCapacityReservation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelCapacityReservation(_a0 *ec2.CancelCapacityReservationInput) (*ec2.CancelCapacityReservationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CancelCapacityReservationOutput
	if rf, ok := ret.Get(0).(func(*ec2.CancelCapacityReservationInput) *ec2.CancelCapacityReservationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelCapacityReservationOutput)
		}
	}

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

	return r0, r1
}

// CancelCapacityReservationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelCapacityReservationRequest(_a0 *ec2.CancelCapacityReservationInput) (*request.Request, *ec2.CancelCapacityReservationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CancelCapacityReservationOutput
	if rf, ok := ret.Get(1).(func(*ec2.CancelCapacityReservationInput) *ec2.CancelCapacityReservationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CancelCapacityReservationOutput)
		}
	}

	return r0, r1
}

// CancelCapacityReservationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CancelCapacityReservationWithContext(_a0 context.Context, _a1 *ec2.CancelCapacityReservationInput, _a2 ...request.Option) (*ec2.CancelCapacityReservationOutput, 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 *ec2.CancelCapacityReservationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelCapacityReservationInput, ...request.Option) *ec2.CancelCapacityReservationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelCapacityReservationOutput)
		}
	}

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

	return r0, r1
}

// CancelConversionTask provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelConversionTask(_a0 *ec2.CancelConversionTaskInput) (*ec2.CancelConversionTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CancelConversionTaskOutput
	if rf, ok := ret.Get(0).(func(*ec2.CancelConversionTaskInput) *ec2.CancelConversionTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelConversionTaskOutput)
		}
	}

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

	return r0, r1
}

// CancelConversionTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelConversionTaskRequest(_a0 *ec2.CancelConversionTaskInput) (*request.Request, *ec2.CancelConversionTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CancelConversionTaskOutput
	if rf, ok := ret.Get(1).(func(*ec2.CancelConversionTaskInput) *ec2.CancelConversionTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CancelConversionTaskOutput)
		}
	}

	return r0, r1
}

// CancelConversionTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CancelConversionTaskWithContext(_a0 context.Context, _a1 *ec2.CancelConversionTaskInput, _a2 ...request.Option) (*ec2.CancelConversionTaskOutput, 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 *ec2.CancelConversionTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelConversionTaskInput, ...request.Option) *ec2.CancelConversionTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelConversionTaskOutput)
		}
	}

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

	return r0, r1
}

// CancelExportTask provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelExportTask(_a0 *ec2.CancelExportTaskInput) (*ec2.CancelExportTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CancelExportTaskOutput
	if rf, ok := ret.Get(0).(func(*ec2.CancelExportTaskInput) *ec2.CancelExportTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelExportTaskOutput)
		}
	}

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

	return r0, r1
}

// CancelExportTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelExportTaskRequest(_a0 *ec2.CancelExportTaskInput) (*request.Request, *ec2.CancelExportTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CancelExportTaskOutput
	if rf, ok := ret.Get(1).(func(*ec2.CancelExportTaskInput) *ec2.CancelExportTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CancelExportTaskOutput)
		}
	}

	return r0, r1
}

// CancelExportTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CancelExportTaskWithContext(_a0 context.Context, _a1 *ec2.CancelExportTaskInput, _a2 ...request.Option) (*ec2.CancelExportTaskOutput, 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 *ec2.CancelExportTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelExportTaskInput, ...request.Option) *ec2.CancelExportTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelExportTaskOutput)
		}
	}

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

	return r0, r1
}

// CancelImportTask provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelImportTask(_a0 *ec2.CancelImportTaskInput) (*ec2.CancelImportTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CancelImportTaskOutput
	if rf, ok := ret.Get(0).(func(*ec2.CancelImportTaskInput) *ec2.CancelImportTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelImportTaskOutput)
		}
	}

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

	return r0, r1
}

// CancelImportTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelImportTaskRequest(_a0 *ec2.CancelImportTaskInput) (*request.Request, *ec2.CancelImportTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CancelImportTaskOutput
	if rf, ok := ret.Get(1).(func(*ec2.CancelImportTaskInput) *ec2.CancelImportTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CancelImportTaskOutput)
		}
	}

	return r0, r1
}

// CancelImportTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CancelImportTaskWithContext(_a0 context.Context, _a1 *ec2.CancelImportTaskInput, _a2 ...request.Option) (*ec2.CancelImportTaskOutput, 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 *ec2.CancelImportTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelImportTaskInput, ...request.Option) *ec2.CancelImportTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelImportTaskOutput)
		}
	}

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

	return r0, r1
}

// CancelReservedInstancesListing provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelReservedInstancesListing(_a0 *ec2.CancelReservedInstancesListingInput) (*ec2.CancelReservedInstancesListingOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CancelReservedInstancesListingOutput
	if rf, ok := ret.Get(0).(func(*ec2.CancelReservedInstancesListingInput) *ec2.CancelReservedInstancesListingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelReservedInstancesListingOutput)
		}
	}

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

	return r0, r1
}

// CancelReservedInstancesListingRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelReservedInstancesListingRequest(_a0 *ec2.CancelReservedInstancesListingInput) (*request.Request, *ec2.CancelReservedInstancesListingOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CancelReservedInstancesListingOutput
	if rf, ok := ret.Get(1).(func(*ec2.CancelReservedInstancesListingInput) *ec2.CancelReservedInstancesListingOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CancelReservedInstancesListingOutput)
		}
	}

	return r0, r1
}

// CancelReservedInstancesListingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CancelReservedInstancesListingWithContext(_a0 context.Context, _a1 *ec2.CancelReservedInstancesListingInput, _a2 ...request.Option) (*ec2.CancelReservedInstancesListingOutput, 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 *ec2.CancelReservedInstancesListingOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelReservedInstancesListingInput, ...request.Option) *ec2.CancelReservedInstancesListingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelReservedInstancesListingOutput)
		}
	}

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

	return r0, r1
}

// CancelSpotFleetRequests provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelSpotFleetRequests(_a0 *ec2.CancelSpotFleetRequestsInput) (*ec2.CancelSpotFleetRequestsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CancelSpotFleetRequestsOutput
	if rf, ok := ret.Get(0).(func(*ec2.CancelSpotFleetRequestsInput) *ec2.CancelSpotFleetRequestsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelSpotFleetRequestsOutput)
		}
	}

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

	return r0, r1
}

// CancelSpotFleetRequestsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelSpotFleetRequestsRequest(_a0 *ec2.CancelSpotFleetRequestsInput) (*request.Request, *ec2.CancelSpotFleetRequestsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CancelSpotFleetRequestsOutput
	if rf, ok := ret.Get(1).(func(*ec2.CancelSpotFleetRequestsInput) *ec2.CancelSpotFleetRequestsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CancelSpotFleetRequestsOutput)
		}
	}

	return r0, r1
}

// CancelSpotFleetRequestsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CancelSpotFleetRequestsWithContext(_a0 context.Context, _a1 *ec2.CancelSpotFleetRequestsInput, _a2 ...request.Option) (*ec2.CancelSpotFleetRequestsOutput, 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 *ec2.CancelSpotFleetRequestsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelSpotFleetRequestsInput, ...request.Option) *ec2.CancelSpotFleetRequestsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelSpotFleetRequestsOutput)
		}
	}

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

	return r0, r1
}

// CancelSpotInstanceRequests provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelSpotInstanceRequests(_a0 *ec2.CancelSpotInstanceRequestsInput) (*ec2.CancelSpotInstanceRequestsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CancelSpotInstanceRequestsOutput
	if rf, ok := ret.Get(0).(func(*ec2.CancelSpotInstanceRequestsInput) *ec2.CancelSpotInstanceRequestsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelSpotInstanceRequestsOutput)
		}
	}

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

	return r0, r1
}

// CancelSpotInstanceRequestsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CancelSpotInstanceRequestsRequest(_a0 *ec2.CancelSpotInstanceRequestsInput) (*request.Request, *ec2.CancelSpotInstanceRequestsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CancelSpotInstanceRequestsOutput
	if rf, ok := ret.Get(1).(func(*ec2.CancelSpotInstanceRequestsInput) *ec2.CancelSpotInstanceRequestsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CancelSpotInstanceRequestsOutput)
		}
	}

	return r0, r1
}

// CancelSpotInstanceRequestsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CancelSpotInstanceRequestsWithContext(_a0 context.Context, _a1 *ec2.CancelSpotInstanceRequestsInput, _a2 ...request.Option) (*ec2.CancelSpotInstanceRequestsOutput, 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 *ec2.CancelSpotInstanceRequestsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelSpotInstanceRequestsInput, ...request.Option) *ec2.CancelSpotInstanceRequestsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelSpotInstanceRequestsOutput)
		}
	}

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

	return r0, r1
}

// ConfirmProductInstance provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ConfirmProductInstance(_a0 *ec2.ConfirmProductInstanceInput) (*ec2.ConfirmProductInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ConfirmProductInstanceOutput
	if rf, ok := ret.Get(0).(func(*ec2.ConfirmProductInstanceInput) *ec2.ConfirmProductInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ConfirmProductInstanceOutput)
		}
	}

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

	return r0, r1
}

// ConfirmProductInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ConfirmProductInstanceRequest(_a0 *ec2.ConfirmProductInstanceInput) (*request.Request, *ec2.ConfirmProductInstanceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.ConfirmProductInstanceOutput
	if rf, ok := ret.Get(1).(func(*ec2.ConfirmProductInstanceInput) *ec2.ConfirmProductInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ConfirmProductInstanceOutput)
		}
	}

	return r0, r1
}

// ConfirmProductInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ConfirmProductInstanceWithContext(_a0 context.Context, _a1 *ec2.ConfirmProductInstanceInput, _a2 ...request.Option) (*ec2.ConfirmProductInstanceOutput, 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 *ec2.ConfirmProductInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ConfirmProductInstanceInput, ...request.Option) *ec2.ConfirmProductInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ConfirmProductInstanceOutput)
		}
	}

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

	return r0, r1
}

// CopyFpgaImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CopyFpgaImage(_a0 *ec2.CopyFpgaImageInput) (*ec2.CopyFpgaImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CopyFpgaImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.CopyFpgaImageInput) *ec2.CopyFpgaImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopyFpgaImageOutput)
		}
	}

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

	return r0, r1
}

// CopyFpgaImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CopyFpgaImageRequest(_a0 *ec2.CopyFpgaImageInput) (*request.Request, *ec2.CopyFpgaImageOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CopyFpgaImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.CopyFpgaImageInput) *ec2.CopyFpgaImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CopyFpgaImageOutput)
		}
	}

	return r0, r1
}

// CopyFpgaImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CopyFpgaImageWithContext(_a0 context.Context, _a1 *ec2.CopyFpgaImageInput, _a2 ...request.Option) (*ec2.CopyFpgaImageOutput, 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 *ec2.CopyFpgaImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopyFpgaImageInput, ...request.Option) *ec2.CopyFpgaImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopyFpgaImageOutput)
		}
	}

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

	return r0, r1
}

// CopyImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CopyImage(_a0 *ec2.CopyImageInput) (*ec2.CopyImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CopyImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.CopyImageInput) *ec2.CopyImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopyImageOutput)
		}
	}

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

	return r0, r1
}

// CopyImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CopyImageRequest(_a0 *ec2.CopyImageInput) (*request.Request, *ec2.CopyImageOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CopyImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.CopyImageInput) *ec2.CopyImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CopyImageOutput)
		}
	}

	return r0, r1
}

// CopyImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CopyImageWithContext(_a0 context.Context, _a1 *ec2.CopyImageInput, _a2 ...request.Option) (*ec2.CopyImageOutput, 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 *ec2.CopyImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopyImageInput, ...request.Option) *ec2.CopyImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopyImageOutput)
		}
	}

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

	return r0, r1
}

// CopySnapshot provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CopySnapshot(_a0 *ec2.CopySnapshotInput) (*ec2.CopySnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CopySnapshotOutput
	if rf, ok := ret.Get(0).(func(*ec2.CopySnapshotInput) *ec2.CopySnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopySnapshotOutput)
		}
	}

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

	return r0, r1
}

// CopySnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CopySnapshotRequest(_a0 *ec2.CopySnapshotInput) (*request.Request, *ec2.CopySnapshotOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CopySnapshotOutput
	if rf, ok := ret.Get(1).(func(*ec2.CopySnapshotInput) *ec2.CopySnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CopySnapshotOutput)
		}
	}

	return r0, r1
}

// CopySnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CopySnapshotWithContext(_a0 context.Context, _a1 *ec2.CopySnapshotInput, _a2 ...request.Option) (*ec2.CopySnapshotOutput, 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 *ec2.CopySnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopySnapshotInput, ...request.Option) *ec2.CopySnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopySnapshotOutput)
		}
	}

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

	return r0, r1
}

// CreateCapacityReservation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateCapacityReservation(_a0 *ec2.CreateCapacityReservationInput) (*ec2.CreateCapacityReservationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateCapacityReservationOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateCapacityReservationInput) *ec2.CreateCapacityReservationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCapacityReservationOutput)
		}
	}

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

	return r0, r1
}

// CreateCapacityReservationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateCapacityReservationRequest(_a0 *ec2.CreateCapacityReservationInput) (*request.Request, *ec2.CreateCapacityReservationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateCapacityReservationOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateCapacityReservationInput) *ec2.CreateCapacityReservationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateCapacityReservationOutput)
		}
	}

	return r0, r1
}

// CreateCapacityReservationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateCapacityReservationWithContext(_a0 context.Context, _a1 *ec2.CreateCapacityReservationInput, _a2 ...request.Option) (*ec2.CreateCapacityReservationOutput, 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 *ec2.CreateCapacityReservationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityReservationInput, ...request.Option) *ec2.CreateCapacityReservationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCapacityReservationOutput)
		}
	}

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

	return r0, r1
}

// CreateCarrierGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateCarrierGateway(_a0 *ec2.CreateCarrierGatewayInput) (*ec2.CreateCarrierGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateCarrierGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateCarrierGatewayInput) *ec2.CreateCarrierGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCarrierGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateCarrierGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateCarrierGatewayRequest(_a0 *ec2.CreateCarrierGatewayInput) (*request.Request, *ec2.CreateCarrierGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateCarrierGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateCarrierGatewayInput) *ec2.CreateCarrierGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateCarrierGatewayOutput)
		}
	}

	return r0, r1
}

// CreateCarrierGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateCarrierGatewayWithContext(_a0 context.Context, _a1 *ec2.CreateCarrierGatewayInput, _a2 ...request.Option) (*ec2.CreateCarrierGatewayOutput, 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 *ec2.CreateCarrierGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCarrierGatewayInput, ...request.Option) *ec2.CreateCarrierGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCarrierGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateClientVpnEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateClientVpnEndpoint(_a0 *ec2.CreateClientVpnEndpointInput) (*ec2.CreateClientVpnEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateClientVpnEndpointOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateClientVpnEndpointInput) *ec2.CreateClientVpnEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateClientVpnEndpointOutput)
		}
	}

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

	return r0, r1
}

// CreateClientVpnEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateClientVpnEndpointRequest(_a0 *ec2.CreateClientVpnEndpointInput) (*request.Request, *ec2.CreateClientVpnEndpointOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateClientVpnEndpointOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateClientVpnEndpointInput) *ec2.CreateClientVpnEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateClientVpnEndpointOutput)
		}
	}

	return r0, r1
}

// CreateClientVpnEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateClientVpnEndpointWithContext(_a0 context.Context, _a1 *ec2.CreateClientVpnEndpointInput, _a2 ...request.Option) (*ec2.CreateClientVpnEndpointOutput, 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 *ec2.CreateClientVpnEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateClientVpnEndpointInput, ...request.Option) *ec2.CreateClientVpnEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateClientVpnEndpointOutput)
		}
	}

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

	return r0, r1
}

// CreateClientVpnRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateClientVpnRoute(_a0 *ec2.CreateClientVpnRouteInput) (*ec2.CreateClientVpnRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateClientVpnRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateClientVpnRouteInput) *ec2.CreateClientVpnRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateClientVpnRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateClientVpnRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateClientVpnRouteRequest(_a0 *ec2.CreateClientVpnRouteInput) (*request.Request, *ec2.CreateClientVpnRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateClientVpnRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateClientVpnRouteInput) *ec2.CreateClientVpnRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateClientVpnRouteOutput)
		}
	}

	return r0, r1
}

// CreateClientVpnRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateClientVpnRouteWithContext(_a0 context.Context, _a1 *ec2.CreateClientVpnRouteInput, _a2 ...request.Option) (*ec2.CreateClientVpnRouteOutput, 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 *ec2.CreateClientVpnRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateClientVpnRouteInput, ...request.Option) *ec2.CreateClientVpnRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateClientVpnRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateCustomerGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateCustomerGateway(_a0 *ec2.CreateCustomerGatewayInput) (*ec2.CreateCustomerGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateCustomerGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateCustomerGatewayInput) *ec2.CreateCustomerGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCustomerGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateCustomerGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateCustomerGatewayRequest(_a0 *ec2.CreateCustomerGatewayInput) (*request.Request, *ec2.CreateCustomerGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateCustomerGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateCustomerGatewayInput) *ec2.CreateCustomerGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateCustomerGatewayOutput)
		}
	}

	return r0, r1
}

// CreateCustomerGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateCustomerGatewayWithContext(_a0 context.Context, _a1 *ec2.CreateCustomerGatewayInput, _a2 ...request.Option) (*ec2.CreateCustomerGatewayOutput, 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 *ec2.CreateCustomerGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCustomerGatewayInput, ...request.Option) *ec2.CreateCustomerGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCustomerGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateDefaultSubnet provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateDefaultSubnet(_a0 *ec2.CreateDefaultSubnetInput) (*ec2.CreateDefaultSubnetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateDefaultSubnetOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateDefaultSubnetInput) *ec2.CreateDefaultSubnetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDefaultSubnetOutput)
		}
	}

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

	return r0, r1
}

// CreateDefaultSubnetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateDefaultSubnetRequest(_a0 *ec2.CreateDefaultSubnetInput) (*request.Request, *ec2.CreateDefaultSubnetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateDefaultSubnetOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateDefaultSubnetInput) *ec2.CreateDefaultSubnetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateDefaultSubnetOutput)
		}
	}

	return r0, r1
}

// CreateDefaultSubnetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateDefaultSubnetWithContext(_a0 context.Context, _a1 *ec2.CreateDefaultSubnetInput, _a2 ...request.Option) (*ec2.CreateDefaultSubnetOutput, 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 *ec2.CreateDefaultSubnetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDefaultSubnetInput, ...request.Option) *ec2.CreateDefaultSubnetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDefaultSubnetOutput)
		}
	}

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

	return r0, r1
}

// CreateDefaultVpc provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateDefaultVpc(_a0 *ec2.CreateDefaultVpcInput) (*ec2.CreateDefaultVpcOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateDefaultVpcOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateDefaultVpcInput) *ec2.CreateDefaultVpcOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDefaultVpcOutput)
		}
	}

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

	return r0, r1
}

// CreateDefaultVpcRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateDefaultVpcRequest(_a0 *ec2.CreateDefaultVpcInput) (*request.Request, *ec2.CreateDefaultVpcOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateDefaultVpcOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateDefaultVpcInput) *ec2.CreateDefaultVpcOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateDefaultVpcOutput)
		}
	}

	return r0, r1
}

// CreateDefaultVpcWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateDefaultVpcWithContext(_a0 context.Context, _a1 *ec2.CreateDefaultVpcInput, _a2 ...request.Option) (*ec2.CreateDefaultVpcOutput, 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 *ec2.CreateDefaultVpcOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDefaultVpcInput, ...request.Option) *ec2.CreateDefaultVpcOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDefaultVpcOutput)
		}
	}

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

	return r0, r1
}

// CreateDhcpOptions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateDhcpOptions(_a0 *ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateDhcpOptionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateDhcpOptionsInput) *ec2.CreateDhcpOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDhcpOptionsOutput)
		}
	}

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

	return r0, r1
}

// CreateDhcpOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateDhcpOptionsRequest(_a0 *ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateDhcpOptionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateDhcpOptionsInput) *ec2.CreateDhcpOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateDhcpOptionsOutput)
		}
	}

	return r0, r1
}

// CreateDhcpOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateDhcpOptionsWithContext(_a0 context.Context, _a1 *ec2.CreateDhcpOptionsInput, _a2 ...request.Option) (*ec2.CreateDhcpOptionsOutput, 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 *ec2.CreateDhcpOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDhcpOptionsInput, ...request.Option) *ec2.CreateDhcpOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDhcpOptionsOutput)
		}
	}

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

	return r0, r1
}

// CreateEgressOnlyInternetGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateEgressOnlyInternetGateway(_a0 *ec2.CreateEgressOnlyInternetGatewayInput) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateEgressOnlyInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateEgressOnlyInternetGatewayInput) *ec2.CreateEgressOnlyInternetGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateEgressOnlyInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateEgressOnlyInternetGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateEgressOnlyInternetGatewayRequest(_a0 *ec2.CreateEgressOnlyInternetGatewayInput) (*request.Request, *ec2.CreateEgressOnlyInternetGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateEgressOnlyInternetGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateEgressOnlyInternetGatewayInput) *ec2.CreateEgressOnlyInternetGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateEgressOnlyInternetGatewayOutput)
		}
	}

	return r0, r1
}

// CreateEgressOnlyInternetGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateEgressOnlyInternetGatewayWithContext(_a0 context.Context, _a1 *ec2.CreateEgressOnlyInternetGatewayInput, _a2 ...request.Option) (*ec2.CreateEgressOnlyInternetGatewayOutput, 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 *ec2.CreateEgressOnlyInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateEgressOnlyInternetGatewayInput, ...request.Option) *ec2.CreateEgressOnlyInternetGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateEgressOnlyInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateFleet provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateFleet(_a0 *ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateFleetOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateFleetInput) *ec2.CreateFleetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFleetOutput)
		}
	}

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

	return r0, r1
}

// CreateFleetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateFleetRequest(_a0 *ec2.CreateFleetInput) (*request.Request, *ec2.CreateFleetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateFleetOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateFleetInput) *ec2.CreateFleetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateFleetOutput)
		}
	}

	return r0, r1
}

// CreateFleetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateFleetWithContext(_a0 context.Context, _a1 *ec2.CreateFleetInput, _a2 ...request.Option) (*ec2.CreateFleetOutput, 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 *ec2.CreateFleetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFleetInput, ...request.Option) *ec2.CreateFleetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFleetOutput)
		}
	}

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

	return r0, r1
}

// CreateFlowLogs provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateFlowLogs(_a0 *ec2.CreateFlowLogsInput) (*ec2.CreateFlowLogsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateFlowLogsOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateFlowLogsInput) *ec2.CreateFlowLogsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFlowLogsOutput)
		}
	}

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

	return r0, r1
}

// CreateFlowLogsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateFlowLogsRequest(_a0 *ec2.CreateFlowLogsInput) (*request.Request, *ec2.CreateFlowLogsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateFlowLogsOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateFlowLogsInput) *ec2.CreateFlowLogsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateFlowLogsOutput)
		}
	}

	return r0, r1
}

// CreateFlowLogsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateFlowLogsWithContext(_a0 context.Context, _a1 *ec2.CreateFlowLogsInput, _a2 ...request.Option) (*ec2.CreateFlowLogsOutput, 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 *ec2.CreateFlowLogsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFlowLogsInput, ...request.Option) *ec2.CreateFlowLogsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFlowLogsOutput)
		}
	}

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

	return r0, r1
}

// CreateFpgaImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateFpgaImage(_a0 *ec2.CreateFpgaImageInput) (*ec2.CreateFpgaImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateFpgaImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateFpgaImageInput) *ec2.CreateFpgaImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFpgaImageOutput)
		}
	}

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

	return r0, r1
}

// CreateFpgaImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateFpgaImageRequest(_a0 *ec2.CreateFpgaImageInput) (*request.Request, *ec2.CreateFpgaImageOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateFpgaImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateFpgaImageInput) *ec2.CreateFpgaImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateFpgaImageOutput)
		}
	}

	return r0, r1
}

// CreateFpgaImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateFpgaImageWithContext(_a0 context.Context, _a1 *ec2.CreateFpgaImageInput, _a2 ...request.Option) (*ec2.CreateFpgaImageOutput, 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 *ec2.CreateFpgaImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFpgaImageInput, ...request.Option) *ec2.CreateFpgaImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFpgaImageOutput)
		}
	}

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

	return r0, r1
}

// CreateImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateImage(_a0 *ec2.CreateImageInput) (*ec2.CreateImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateImageInput) *ec2.CreateImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateImageOutput)
		}
	}

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

	return r0, r1
}

// CreateImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateImageRequest(_a0 *ec2.CreateImageInput) (*request.Request, *ec2.CreateImageOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateImageInput) *ec2.CreateImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateImageOutput)
		}
	}

	return r0, r1
}

// CreateImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateImageWithContext(_a0 context.Context, _a1 *ec2.CreateImageInput, _a2 ...request.Option) (*ec2.CreateImageOutput, 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 *ec2.CreateImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateImageInput, ...request.Option) *ec2.CreateImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateImageOutput)
		}
	}

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

	return r0, r1
}

// CreateInstanceExportTask provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateInstanceExportTask(_a0 *ec2.CreateInstanceExportTaskInput) (*ec2.CreateInstanceExportTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateInstanceExportTaskOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateInstanceExportTaskInput) *ec2.CreateInstanceExportTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInstanceExportTaskOutput)
		}
	}

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

	return r0, r1
}

// CreateInstanceExportTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateInstanceExportTaskRequest(_a0 *ec2.CreateInstanceExportTaskInput) (*request.Request, *ec2.CreateInstanceExportTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateInstanceExportTaskOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateInstanceExportTaskInput) *ec2.CreateInstanceExportTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateInstanceExportTaskOutput)
		}
	}

	return r0, r1
}

// CreateInstanceExportTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateInstanceExportTaskWithContext(_a0 context.Context, _a1 *ec2.CreateInstanceExportTaskInput, _a2 ...request.Option) (*ec2.CreateInstanceExportTaskOutput, 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 *ec2.CreateInstanceExportTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInstanceExportTaskInput, ...request.Option) *ec2.CreateInstanceExportTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInstanceExportTaskOutput)
		}
	}

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

	return r0, r1
}

// CreateInternetGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateInternetGateway(_a0 *ec2.CreateInternetGatewayInput) (*ec2.CreateInternetGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateInternetGatewayInput) *ec2.CreateInternetGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateInternetGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateInternetGatewayRequest(_a0 *ec2.CreateInternetGatewayInput) (*request.Request, *ec2.CreateInternetGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateInternetGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateInternetGatewayInput) *ec2.CreateInternetGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateInternetGatewayOutput)
		}
	}

	return r0, r1
}

// CreateInternetGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateInternetGatewayWithContext(_a0 context.Context, _a1 *ec2.CreateInternetGatewayInput, _a2 ...request.Option) (*ec2.CreateInternetGatewayOutput, 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 *ec2.CreateInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInternetGatewayInput, ...request.Option) *ec2.CreateInternetGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateKeyPair provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateKeyPair(_a0 *ec2.CreateKeyPairInput) (*ec2.CreateKeyPairOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateKeyPairOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateKeyPairInput) *ec2.CreateKeyPairOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateKeyPairOutput)
		}
	}

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

	return r0, r1
}

// CreateKeyPairRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateKeyPairRequest(_a0 *ec2.CreateKeyPairInput) (*request.Request, *ec2.CreateKeyPairOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateKeyPairOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateKeyPairInput) *ec2.CreateKeyPairOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateKeyPairOutput)
		}
	}

	return r0, r1
}

// CreateKeyPairWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateKeyPairWithContext(_a0 context.Context, _a1 *ec2.CreateKeyPairInput, _a2 ...request.Option) (*ec2.CreateKeyPairOutput, 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 *ec2.CreateKeyPairOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateKeyPairInput, ...request.Option) *ec2.CreateKeyPairOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateKeyPairOutput)
		}
	}

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

	return r0, r1
}

// CreateLaunchTemplate provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateLaunchTemplate(_a0 *ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateLaunchTemplateOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateLaunchTemplateInput) *ec2.CreateLaunchTemplateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLaunchTemplateOutput)
		}
	}

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

	return r0, r1
}

// CreateLaunchTemplateRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateLaunchTemplateRequest(_a0 *ec2.CreateLaunchTemplateInput) (*request.Request, *ec2.CreateLaunchTemplateOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateLaunchTemplateOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateLaunchTemplateInput) *ec2.CreateLaunchTemplateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateLaunchTemplateOutput)
		}
	}

	return r0, r1
}

// CreateLaunchTemplateVersion provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateLaunchTemplateVersion(_a0 *ec2.CreateLaunchTemplateVersionInput) (*ec2.CreateLaunchTemplateVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateLaunchTemplateVersionOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateLaunchTemplateVersionInput) *ec2.CreateLaunchTemplateVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLaunchTemplateVersionOutput)
		}
	}

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

	return r0, r1
}

// CreateLaunchTemplateVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateLaunchTemplateVersionRequest(_a0 *ec2.CreateLaunchTemplateVersionInput) (*request.Request, *ec2.CreateLaunchTemplateVersionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateLaunchTemplateVersionOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateLaunchTemplateVersionInput) *ec2.CreateLaunchTemplateVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateLaunchTemplateVersionOutput)
		}
	}

	return r0, r1
}

// CreateLaunchTemplateVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateLaunchTemplateVersionWithContext(_a0 context.Context, _a1 *ec2.CreateLaunchTemplateVersionInput, _a2 ...request.Option) (*ec2.CreateLaunchTemplateVersionOutput, 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 *ec2.CreateLaunchTemplateVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLaunchTemplateVersionInput, ...request.Option) *ec2.CreateLaunchTemplateVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLaunchTemplateVersionOutput)
		}
	}

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

	return r0, r1
}

// CreateLaunchTemplateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateLaunchTemplateWithContext(_a0 context.Context, _a1 *ec2.CreateLaunchTemplateInput, _a2 ...request.Option) (*ec2.CreateLaunchTemplateOutput, 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 *ec2.CreateLaunchTemplateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLaunchTemplateInput, ...request.Option) *ec2.CreateLaunchTemplateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLaunchTemplateOutput)
		}
	}

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

	return r0, r1
}

// CreateLocalGatewayRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateLocalGatewayRoute(_a0 *ec2.CreateLocalGatewayRouteInput) (*ec2.CreateLocalGatewayRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateLocalGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateLocalGatewayRouteInput) *ec2.CreateLocalGatewayRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateLocalGatewayRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateLocalGatewayRouteRequest(_a0 *ec2.CreateLocalGatewayRouteInput) (*request.Request, *ec2.CreateLocalGatewayRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateLocalGatewayRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateLocalGatewayRouteInput) *ec2.CreateLocalGatewayRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateLocalGatewayRouteOutput)
		}
	}

	return r0, r1
}

// CreateLocalGatewayRouteTableVpcAssociation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateLocalGatewayRouteTableVpcAssociation(_a0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateLocalGatewayRouteTableVpcAssociationInput) *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
		}
	}

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

	return r0, r1
}

// CreateLocalGatewayRouteTableVpcAssociationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateLocalGatewayRouteTableVpcAssociationRequest(_a0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateLocalGatewayRouteTableVpcAssociationInput) *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
		}
	}

	return r0, r1
}

// CreateLocalGatewayRouteTableVpcAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateLocalGatewayRouteTableVpcAssociationWithContext(_a0 context.Context, _a1 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, _a2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, 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 *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, ...request.Option) *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
		}
	}

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

	return r0, r1
}

// CreateLocalGatewayRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateLocalGatewayRouteWithContext(_a0 context.Context, _a1 *ec2.CreateLocalGatewayRouteInput, _a2 ...request.Option) (*ec2.CreateLocalGatewayRouteOutput, 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 *ec2.CreateLocalGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteInput, ...request.Option) *ec2.CreateLocalGatewayRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateManagedPrefixList provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateManagedPrefixList(_a0 *ec2.CreateManagedPrefixListInput) (*ec2.CreateManagedPrefixListOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateManagedPrefixListOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateManagedPrefixListInput) *ec2.CreateManagedPrefixListOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateManagedPrefixListOutput)
		}
	}

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

	return r0, r1
}

// CreateManagedPrefixListRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateManagedPrefixListRequest(_a0 *ec2.CreateManagedPrefixListInput) (*request.Request, *ec2.CreateManagedPrefixListOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateManagedPrefixListOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateManagedPrefixListInput) *ec2.CreateManagedPrefixListOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateManagedPrefixListOutput)
		}
	}

	return r0, r1
}

// CreateManagedPrefixListWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateManagedPrefixListWithContext(_a0 context.Context, _a1 *ec2.CreateManagedPrefixListInput, _a2 ...request.Option) (*ec2.CreateManagedPrefixListOutput, 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 *ec2.CreateManagedPrefixListOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateManagedPrefixListInput, ...request.Option) *ec2.CreateManagedPrefixListOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateManagedPrefixListOutput)
		}
	}

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

	return r0, r1
}

// CreateNatGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNatGateway(_a0 *ec2.CreateNatGatewayInput) (*ec2.CreateNatGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateNatGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateNatGatewayInput) *ec2.CreateNatGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNatGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateNatGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNatGatewayRequest(_a0 *ec2.CreateNatGatewayInput) (*request.Request, *ec2.CreateNatGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateNatGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateNatGatewayInput) *ec2.CreateNatGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateNatGatewayOutput)
		}
	}

	return r0, r1
}

// CreateNatGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateNatGatewayWithContext(_a0 context.Context, _a1 *ec2.CreateNatGatewayInput, _a2 ...request.Option) (*ec2.CreateNatGatewayOutput, 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 *ec2.CreateNatGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNatGatewayInput, ...request.Option) *ec2.CreateNatGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNatGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkAcl provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkAcl(_a0 *ec2.CreateNetworkAclInput) (*ec2.CreateNetworkAclOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateNetworkAclOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateNetworkAclInput) *ec2.CreateNetworkAclOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkAclOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkAclEntry provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkAclEntry(_a0 *ec2.CreateNetworkAclEntryInput) (*ec2.CreateNetworkAclEntryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateNetworkAclEntryOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateNetworkAclEntryInput) *ec2.CreateNetworkAclEntryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkAclEntryOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkAclEntryRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkAclEntryRequest(_a0 *ec2.CreateNetworkAclEntryInput) (*request.Request, *ec2.CreateNetworkAclEntryOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateNetworkAclEntryOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateNetworkAclEntryInput) *ec2.CreateNetworkAclEntryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateNetworkAclEntryOutput)
		}
	}

	return r0, r1
}

// CreateNetworkAclEntryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateNetworkAclEntryWithContext(_a0 context.Context, _a1 *ec2.CreateNetworkAclEntryInput, _a2 ...request.Option) (*ec2.CreateNetworkAclEntryOutput, 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 *ec2.CreateNetworkAclEntryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkAclEntryInput, ...request.Option) *ec2.CreateNetworkAclEntryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkAclEntryOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkAclRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkAclRequest(_a0 *ec2.CreateNetworkAclInput) (*request.Request, *ec2.CreateNetworkAclOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateNetworkAclOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateNetworkAclInput) *ec2.CreateNetworkAclOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateNetworkAclOutput)
		}
	}

	return r0, r1
}

// CreateNetworkAclWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateNetworkAclWithContext(_a0 context.Context, _a1 *ec2.CreateNetworkAclInput, _a2 ...request.Option) (*ec2.CreateNetworkAclOutput, 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 *ec2.CreateNetworkAclOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkAclInput, ...request.Option) *ec2.CreateNetworkAclOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkAclOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkInsightsPath provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkInsightsPath(_a0 *ec2.CreateNetworkInsightsPathInput) (*ec2.CreateNetworkInsightsPathOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateNetworkInsightsPathOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateNetworkInsightsPathInput) *ec2.CreateNetworkInsightsPathOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInsightsPathOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkInsightsPathRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkInsightsPathRequest(_a0 *ec2.CreateNetworkInsightsPathInput) (*request.Request, *ec2.CreateNetworkInsightsPathOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateNetworkInsightsPathOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateNetworkInsightsPathInput) *ec2.CreateNetworkInsightsPathOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateNetworkInsightsPathOutput)
		}
	}

	return r0, r1
}

// CreateNetworkInsightsPathWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateNetworkInsightsPathWithContext(_a0 context.Context, _a1 *ec2.CreateNetworkInsightsPathInput, _a2 ...request.Option) (*ec2.CreateNetworkInsightsPathOutput, 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 *ec2.CreateNetworkInsightsPathOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInsightsPathInput, ...request.Option) *ec2.CreateNetworkInsightsPathOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInsightsPathOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkInterface provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkInterface(_a0 *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateNetworkInterfaceOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateNetworkInterfaceInput) *ec2.CreateNetworkInterfaceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInterfaceOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkInterfacePermission provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkInterfacePermission(_a0 *ec2.CreateNetworkInterfacePermissionInput) (*ec2.CreateNetworkInterfacePermissionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateNetworkInterfacePermissionOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateNetworkInterfacePermissionInput) *ec2.CreateNetworkInterfacePermissionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInterfacePermissionOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkInterfacePermissionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkInterfacePermissionRequest(_a0 *ec2.CreateNetworkInterfacePermissionInput) (*request.Request, *ec2.CreateNetworkInterfacePermissionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateNetworkInterfacePermissionOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateNetworkInterfacePermissionInput) *ec2.CreateNetworkInterfacePermissionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateNetworkInterfacePermissionOutput)
		}
	}

	return r0, r1
}

// CreateNetworkInterfacePermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateNetworkInterfacePermissionWithContext(_a0 context.Context, _a1 *ec2.CreateNetworkInterfacePermissionInput, _a2 ...request.Option) (*ec2.CreateNetworkInterfacePermissionOutput, 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 *ec2.CreateNetworkInterfacePermissionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInterfacePermissionInput, ...request.Option) *ec2.CreateNetworkInterfacePermissionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInterfacePermissionOutput)
		}
	}

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

	return r0, r1
}

// CreateNetworkInterfaceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateNetworkInterfaceRequest(_a0 *ec2.CreateNetworkInterfaceInput) (*request.Request, *ec2.CreateNetworkInterfaceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateNetworkInterfaceOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateNetworkInterfaceInput) *ec2.CreateNetworkInterfaceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateNetworkInterfaceOutput)
		}
	}

	return r0, r1
}

// CreateNetworkInterfaceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateNetworkInterfaceWithContext(_a0 context.Context, _a1 *ec2.CreateNetworkInterfaceInput, _a2 ...request.Option) (*ec2.CreateNetworkInterfaceOutput, 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 *ec2.CreateNetworkInterfaceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInterfaceInput, ...request.Option) *ec2.CreateNetworkInterfaceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInterfaceOutput)
		}
	}

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

	return r0, r1
}

// CreatePlacementGroup provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreatePlacementGroup(_a0 *ec2.CreatePlacementGroupInput) (*ec2.CreatePlacementGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreatePlacementGroupOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreatePlacementGroupInput) *ec2.CreatePlacementGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreatePlacementGroupOutput)
		}
	}

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

	return r0, r1
}

// CreatePlacementGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreatePlacementGroupRequest(_a0 *ec2.CreatePlacementGroupInput) (*request.Request, *ec2.CreatePlacementGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreatePlacementGroupOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreatePlacementGroupInput) *ec2.CreatePlacementGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreatePlacementGroupOutput)
		}
	}

	return r0, r1
}

// CreatePlacementGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreatePlacementGroupWithContext(_a0 context.Context, _a1 *ec2.CreatePlacementGroupInput, _a2 ...request.Option) (*ec2.CreatePlacementGroupOutput, 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 *ec2.CreatePlacementGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreatePlacementGroupInput, ...request.Option) *ec2.CreatePlacementGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreatePlacementGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateReplaceRootVolumeTask provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateReplaceRootVolumeTask(_a0 *ec2.CreateReplaceRootVolumeTaskInput) (*ec2.CreateReplaceRootVolumeTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateReplaceRootVolumeTaskOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateReplaceRootVolumeTaskInput) *ec2.CreateReplaceRootVolumeTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateReplaceRootVolumeTaskOutput)
		}
	}

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

	return r0, r1
}

// CreateReplaceRootVolumeTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateReplaceRootVolumeTaskRequest(_a0 *ec2.CreateReplaceRootVolumeTaskInput) (*request.Request, *ec2.CreateReplaceRootVolumeTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateReplaceRootVolumeTaskOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateReplaceRootVolumeTaskInput) *ec2.CreateReplaceRootVolumeTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateReplaceRootVolumeTaskOutput)
		}
	}

	return r0, r1
}

// CreateReplaceRootVolumeTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateReplaceRootVolumeTaskWithContext(_a0 context.Context, _a1 *ec2.CreateReplaceRootVolumeTaskInput, _a2 ...request.Option) (*ec2.CreateReplaceRootVolumeTaskOutput, 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 *ec2.CreateReplaceRootVolumeTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateReplaceRootVolumeTaskInput, ...request.Option) *ec2.CreateReplaceRootVolumeTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateReplaceRootVolumeTaskOutput)
		}
	}

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

	return r0, r1
}

// CreateReservedInstancesListing provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateReservedInstancesListing(_a0 *ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateReservedInstancesListingOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateReservedInstancesListingInput) *ec2.CreateReservedInstancesListingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateReservedInstancesListingOutput)
		}
	}

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

	return r0, r1
}

// CreateReservedInstancesListingRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateReservedInstancesListingRequest(_a0 *ec2.CreateReservedInstancesListingInput) (*request.Request, *ec2.CreateReservedInstancesListingOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateReservedInstancesListingOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateReservedInstancesListingInput) *ec2.CreateReservedInstancesListingOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateReservedInstancesListingOutput)
		}
	}

	return r0, r1
}

// CreateReservedInstancesListingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateReservedInstancesListingWithContext(_a0 context.Context, _a1 *ec2.CreateReservedInstancesListingInput, _a2 ...request.Option) (*ec2.CreateReservedInstancesListingOutput, 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 *ec2.CreateReservedInstancesListingOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateReservedInstancesListingInput, ...request.Option) *ec2.CreateReservedInstancesListingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateReservedInstancesListingOutput)
		}
	}

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

	return r0, r1
}

// CreateRestoreImageTask provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateRestoreImageTask(_a0 *ec2.CreateRestoreImageTaskInput) (*ec2.CreateRestoreImageTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateRestoreImageTaskOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateRestoreImageTaskInput) *ec2.CreateRestoreImageTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRestoreImageTaskOutput)
		}
	}

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

	return r0, r1
}

// CreateRestoreImageTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateRestoreImageTaskRequest(_a0 *ec2.CreateRestoreImageTaskInput) (*request.Request, *ec2.CreateRestoreImageTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateRestoreImageTaskOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateRestoreImageTaskInput) *ec2.CreateRestoreImageTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateRestoreImageTaskOutput)
		}
	}

	return r0, r1
}

// CreateRestoreImageTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateRestoreImageTaskWithContext(_a0 context.Context, _a1 *ec2.CreateRestoreImageTaskInput, _a2 ...request.Option) (*ec2.CreateRestoreImageTaskOutput, 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 *ec2.CreateRestoreImageTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRestoreImageTaskInput, ...request.Option) *ec2.CreateRestoreImageTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRestoreImageTaskOutput)
		}
	}

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

	return r0, r1
}

// CreateRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateRoute(_a0 *ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateRouteInput) *ec2.CreateRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateRouteRequest(_a0 *ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateRouteInput) *ec2.CreateRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateRouteOutput)
		}
	}

	return r0, r1
}

// CreateRouteTable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateRouteTable(_a0 *ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateRouteTableOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateRouteTableInput) *ec2.CreateRouteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteTableOutput)
		}
	}

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

	return r0, r1
}

// CreateRouteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateRouteTableRequest(_a0 *ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateRouteTableOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateRouteTableInput) *ec2.CreateRouteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateRouteTableOutput)
		}
	}

	return r0, r1
}

// CreateRouteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateRouteTableWithContext(_a0 context.Context, _a1 *ec2.CreateRouteTableInput, _a2 ...request.Option) (*ec2.CreateRouteTableOutput, 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 *ec2.CreateRouteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteTableInput, ...request.Option) *ec2.CreateRouteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteTableOutput)
		}
	}

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

	return r0, r1
}

// CreateRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateRouteWithContext(_a0 context.Context, _a1 *ec2.CreateRouteInput, _a2 ...request.Option) (*ec2.CreateRouteOutput, 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 *ec2.CreateRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteInput, ...request.Option) *ec2.CreateRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateSecurityGroup provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSecurityGroup(_a0 *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateSecurityGroupInput) *ec2.CreateSecurityGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateSecurityGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSecurityGroupRequest(_a0 *ec2.CreateSecurityGroupInput) (*request.Request, *ec2.CreateSecurityGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateSecurityGroupOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateSecurityGroupInput) *ec2.CreateSecurityGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateSecurityGroupOutput)
		}
	}

	return r0, r1
}

// CreateSecurityGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateSecurityGroupWithContext(_a0 context.Context, _a1 *ec2.CreateSecurityGroupInput, _a2 ...request.Option) (*ec2.CreateSecurityGroupOutput, 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 *ec2.CreateSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSecurityGroupInput, ...request.Option) *ec2.CreateSecurityGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSnapshot(_a0 *ec2.CreateSnapshotInput) (*ec2.Snapshot, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.Snapshot
	if rf, ok := ret.Get(0).(func(*ec2.CreateSnapshotInput) *ec2.Snapshot); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.Snapshot)
		}
	}

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

	return r0, r1
}

// CreateSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSnapshotRequest(_a0 *ec2.CreateSnapshotInput) (*request.Request, *ec2.Snapshot) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.Snapshot
	if rf, ok := ret.Get(1).(func(*ec2.CreateSnapshotInput) *ec2.Snapshot); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.Snapshot)
		}
	}

	return r0, r1
}

// CreateSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateSnapshotWithContext(_a0 context.Context, _a1 *ec2.CreateSnapshotInput, _a2 ...request.Option) (*ec2.Snapshot, 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 *ec2.Snapshot
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSnapshotInput, ...request.Option) *ec2.Snapshot); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.Snapshot)
		}
	}

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

	return r0, r1
}

// CreateSnapshots provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSnapshots(_a0 *ec2.CreateSnapshotsInput) (*ec2.CreateSnapshotsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateSnapshotsOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateSnapshotsInput) *ec2.CreateSnapshotsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSnapshotsOutput)
		}
	}

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

	return r0, r1
}

// CreateSnapshotsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSnapshotsRequest(_a0 *ec2.CreateSnapshotsInput) (*request.Request, *ec2.CreateSnapshotsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateSnapshotsOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateSnapshotsInput) *ec2.CreateSnapshotsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateSnapshotsOutput)
		}
	}

	return r0, r1
}

// CreateSnapshotsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateSnapshotsWithContext(_a0 context.Context, _a1 *ec2.CreateSnapshotsInput, _a2 ...request.Option) (*ec2.CreateSnapshotsOutput, 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 *ec2.CreateSnapshotsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSnapshotsInput, ...request.Option) *ec2.CreateSnapshotsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSnapshotsOutput)
		}
	}

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

	return r0, r1
}

// CreateSpotDatafeedSubscription provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSpotDatafeedSubscription(_a0 *ec2.CreateSpotDatafeedSubscriptionInput) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateSpotDatafeedSubscriptionInput) *ec2.CreateSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSpotDatafeedSubscriptionOutput)
		}
	}

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

	return r0, r1
}

// CreateSpotDatafeedSubscriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSpotDatafeedSubscriptionRequest(_a0 *ec2.CreateSpotDatafeedSubscriptionInput) (*request.Request, *ec2.CreateSpotDatafeedSubscriptionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateSpotDatafeedSubscriptionInput) *ec2.CreateSpotDatafeedSubscriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateSpotDatafeedSubscriptionOutput)
		}
	}

	return r0, r1
}

// CreateSpotDatafeedSubscriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateSpotDatafeedSubscriptionWithContext(_a0 context.Context, _a1 *ec2.CreateSpotDatafeedSubscriptionInput, _a2 ...request.Option) (*ec2.CreateSpotDatafeedSubscriptionOutput, 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 *ec2.CreateSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSpotDatafeedSubscriptionInput, ...request.Option) *ec2.CreateSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSpotDatafeedSubscriptionOutput)
		}
	}

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

	return r0, r1
}

// CreateStoreImageTask provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateStoreImageTask(_a0 *ec2.CreateStoreImageTaskInput) (*ec2.CreateStoreImageTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateStoreImageTaskOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateStoreImageTaskInput) *ec2.CreateStoreImageTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateStoreImageTaskOutput)
		}
	}

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

	return r0, r1
}

// CreateStoreImageTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateStoreImageTaskRequest(_a0 *ec2.CreateStoreImageTaskInput) (*request.Request, *ec2.CreateStoreImageTaskOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateStoreImageTaskOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateStoreImageTaskInput) *ec2.CreateStoreImageTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateStoreImageTaskOutput)
		}
	}

	return r0, r1
}

// CreateStoreImageTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateStoreImageTaskWithContext(_a0 context.Context, _a1 *ec2.CreateStoreImageTaskInput, _a2 ...request.Option) (*ec2.CreateStoreImageTaskOutput, 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 *ec2.CreateStoreImageTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateStoreImageTaskInput, ...request.Option) *ec2.CreateStoreImageTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateStoreImageTaskOutput)
		}
	}

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

	return r0, r1
}

// CreateSubnet provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSubnet(_a0 *ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateSubnetOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateSubnetInput) *ec2.CreateSubnetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSubnetOutput)
		}
	}

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

	return r0, r1
}

// CreateSubnetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateSubnetRequest(_a0 *ec2.CreateSubnetInput) (*request.Request, *ec2.CreateSubnetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateSubnetOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateSubnetInput) *ec2.CreateSubnetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateSubnetOutput)
		}
	}

	return r0, r1
}

// CreateSubnetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateSubnetWithContext(_a0 context.Context, _a1 *ec2.CreateSubnetInput, _a2 ...request.Option) (*ec2.CreateSubnetOutput, 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 *ec2.CreateSubnetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSubnetInput, ...request.Option) *ec2.CreateSubnetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSubnetOutput)
		}
	}

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

	return r0, r1
}

// CreateTags provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTags(_a0 *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTagsOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTagsInput) *ec2.CreateTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTagsOutput)
		}
	}

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

	return r0, r1
}

// CreateTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTagsRequest(_a0 *ec2.CreateTagsInput) (*request.Request, *ec2.CreateTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTagsOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTagsInput) *ec2.CreateTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTagsOutput)
		}
	}

	return r0, r1
}

// CreateTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTagsWithContext(_a0 context.Context, _a1 *ec2.CreateTagsInput, _a2 ...request.Option) (*ec2.CreateTagsOutput, 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 *ec2.CreateTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTagsInput, ...request.Option) *ec2.CreateTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTagsOutput)
		}
	}

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

	return r0, r1
}

// CreateTrafficMirrorFilter provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTrafficMirrorFilter(_a0 *ec2.CreateTrafficMirrorFilterInput) (*ec2.CreateTrafficMirrorFilterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTrafficMirrorFilterOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTrafficMirrorFilterInput) *ec2.CreateTrafficMirrorFilterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorFilterOutput)
		}
	}

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

	return r0, r1
}

// CreateTrafficMirrorFilterRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTrafficMirrorFilterRequest(_a0 *ec2.CreateTrafficMirrorFilterInput) (*request.Request, *ec2.CreateTrafficMirrorFilterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTrafficMirrorFilterOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTrafficMirrorFilterInput) *ec2.CreateTrafficMirrorFilterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTrafficMirrorFilterOutput)
		}
	}

	return r0, r1
}

// CreateTrafficMirrorFilterRule provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTrafficMirrorFilterRule(_a0 *ec2.CreateTrafficMirrorFilterRuleInput) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTrafficMirrorFilterRuleInput) *ec2.CreateTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorFilterRuleOutput)
		}
	}

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

	return r0, r1
}

// CreateTrafficMirrorFilterRuleRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTrafficMirrorFilterRuleRequest(_a0 *ec2.CreateTrafficMirrorFilterRuleInput) (*request.Request, *ec2.CreateTrafficMirrorFilterRuleOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTrafficMirrorFilterRuleInput) *ec2.CreateTrafficMirrorFilterRuleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTrafficMirrorFilterRuleOutput)
		}
	}

	return r0, r1
}

// CreateTrafficMirrorFilterRuleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTrafficMirrorFilterRuleWithContext(_a0 context.Context, _a1 *ec2.CreateTrafficMirrorFilterRuleInput, _a2 ...request.Option) (*ec2.CreateTrafficMirrorFilterRuleOutput, 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 *ec2.CreateTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorFilterRuleInput, ...request.Option) *ec2.CreateTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorFilterRuleOutput)
		}
	}

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

	return r0, r1
}

// CreateTrafficMirrorFilterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTrafficMirrorFilterWithContext(_a0 context.Context, _a1 *ec2.CreateTrafficMirrorFilterInput, _a2 ...request.Option) (*ec2.CreateTrafficMirrorFilterOutput, 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 *ec2.CreateTrafficMirrorFilterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorFilterInput, ...request.Option) *ec2.CreateTrafficMirrorFilterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorFilterOutput)
		}
	}

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

	return r0, r1
}

// CreateTrafficMirrorSession provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTrafficMirrorSession(_a0 *ec2.CreateTrafficMirrorSessionInput) (*ec2.CreateTrafficMirrorSessionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTrafficMirrorSessionOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTrafficMirrorSessionInput) *ec2.CreateTrafficMirrorSessionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorSessionOutput)
		}
	}

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

	return r0, r1
}

// CreateTrafficMirrorSessionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTrafficMirrorSessionRequest(_a0 *ec2.CreateTrafficMirrorSessionInput) (*request.Request, *ec2.CreateTrafficMirrorSessionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTrafficMirrorSessionOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTrafficMirrorSessionInput) *ec2.CreateTrafficMirrorSessionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTrafficMirrorSessionOutput)
		}
	}

	return r0, r1
}

// CreateTrafficMirrorSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTrafficMirrorSessionWithContext(_a0 context.Context, _a1 *ec2.CreateTrafficMirrorSessionInput, _a2 ...request.Option) (*ec2.CreateTrafficMirrorSessionOutput, 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 *ec2.CreateTrafficMirrorSessionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorSessionInput, ...request.Option) *ec2.CreateTrafficMirrorSessionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorSessionOutput)
		}
	}

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

	return r0, r1
}

// CreateTrafficMirrorTarget provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTrafficMirrorTarget(_a0 *ec2.CreateTrafficMirrorTargetInput) (*ec2.CreateTrafficMirrorTargetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTrafficMirrorTargetOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTrafficMirrorTargetInput) *ec2.CreateTrafficMirrorTargetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorTargetOutput)
		}
	}

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

	return r0, r1
}

// CreateTrafficMirrorTargetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTrafficMirrorTargetRequest(_a0 *ec2.CreateTrafficMirrorTargetInput) (*request.Request, *ec2.CreateTrafficMirrorTargetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTrafficMirrorTargetOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTrafficMirrorTargetInput) *ec2.CreateTrafficMirrorTargetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTrafficMirrorTargetOutput)
		}
	}

	return r0, r1
}

// CreateTrafficMirrorTargetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTrafficMirrorTargetWithContext(_a0 context.Context, _a1 *ec2.CreateTrafficMirrorTargetInput, _a2 ...request.Option) (*ec2.CreateTrafficMirrorTargetOutput, 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 *ec2.CreateTrafficMirrorTargetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorTargetInput, ...request.Option) *ec2.CreateTrafficMirrorTargetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorTargetOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGateway(_a0 *ec2.CreateTransitGatewayInput) (*ec2.CreateTransitGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayInput) *ec2.CreateTransitGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayConnect provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayConnect(_a0 *ec2.CreateTransitGatewayConnectInput) (*ec2.CreateTransitGatewayConnectOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayConnectOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayConnectInput) *ec2.CreateTransitGatewayConnectOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayConnectOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayConnectPeer provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayConnectPeer(_a0 *ec2.CreateTransitGatewayConnectPeerInput) (*ec2.CreateTransitGatewayConnectPeerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayConnectPeerOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayConnectPeerInput) *ec2.CreateTransitGatewayConnectPeerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayConnectPeerOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayConnectPeerRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayConnectPeerRequest(_a0 *ec2.CreateTransitGatewayConnectPeerInput) (*request.Request, *ec2.CreateTransitGatewayConnectPeerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayConnectPeerOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayConnectPeerInput) *ec2.CreateTransitGatewayConnectPeerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayConnectPeerOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayConnectPeerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayConnectPeerWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayConnectPeerInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayConnectPeerOutput, 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 *ec2.CreateTransitGatewayConnectPeerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayConnectPeerInput, ...request.Option) *ec2.CreateTransitGatewayConnectPeerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayConnectPeerOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayConnectRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayConnectRequest(_a0 *ec2.CreateTransitGatewayConnectInput) (*request.Request, *ec2.CreateTransitGatewayConnectOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayConnectOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayConnectInput) *ec2.CreateTransitGatewayConnectOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayConnectOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayConnectWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayConnectWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayConnectInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayConnectOutput, 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 *ec2.CreateTransitGatewayConnectOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayConnectInput, ...request.Option) *ec2.CreateTransitGatewayConnectOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayConnectOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayMulticastDomain provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayMulticastDomain(_a0 *ec2.CreateTransitGatewayMulticastDomainInput) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayMulticastDomainInput) *ec2.CreateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayMulticastDomainOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayMulticastDomainRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayMulticastDomainRequest(_a0 *ec2.CreateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.CreateTransitGatewayMulticastDomainOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayMulticastDomainInput) *ec2.CreateTransitGatewayMulticastDomainOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayMulticastDomainOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayMulticastDomainWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayMulticastDomainWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayMulticastDomainInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayMulticastDomainOutput, 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 *ec2.CreateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMulticastDomainInput, ...request.Option) *ec2.CreateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayMulticastDomainOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayPeeringAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayPeeringAttachment(_a0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayPeeringAttachmentInput) *ec2.CreateTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayPeeringAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayPeeringAttachmentRequest(_a0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayPeeringAttachmentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayPeeringAttachmentInput) *ec2.CreateTransitGatewayPeeringAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayPeeringAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayPeeringAttachmentWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayPeeringAttachmentInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, 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 *ec2.CreateTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayPeeringAttachmentInput, ...request.Option) *ec2.CreateTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayPrefixListReference provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayPrefixListReference(_a0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayPrefixListReferenceInput) *ec2.CreateTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayPrefixListReferenceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayPrefixListReferenceRequest(_a0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.CreateTransitGatewayPrefixListReferenceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayPrefixListReferenceInput) *ec2.CreateTransitGatewayPrefixListReferenceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayPrefixListReferenceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayPrefixListReferenceWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayPrefixListReferenceInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, 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 *ec2.CreateTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayPrefixListReferenceInput, ...request.Option) *ec2.CreateTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayRequest(_a0 *ec2.CreateTransitGatewayInput) (*request.Request, *ec2.CreateTransitGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayInput) *ec2.CreateTransitGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayRoute(_a0 *ec2.CreateTransitGatewayRouteInput) (*ec2.CreateTransitGatewayRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayRouteInput) *ec2.CreateTransitGatewayRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayRouteRequest(_a0 *ec2.CreateTransitGatewayRouteInput) (*request.Request, *ec2.CreateTransitGatewayRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayRouteInput) *ec2.CreateTransitGatewayRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayRouteOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayRouteTable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayRouteTable(_a0 *ec2.CreateTransitGatewayRouteTableInput) (*ec2.CreateTransitGatewayRouteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayRouteTableInput) *ec2.CreateTransitGatewayRouteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayRouteTableOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayRouteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayRouteTableRequest(_a0 *ec2.CreateTransitGatewayRouteTableInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayRouteTableInput) *ec2.CreateTransitGatewayRouteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayRouteTableOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayRouteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayRouteTableWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayRouteTableInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableOutput, 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 *ec2.CreateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayRouteTableInput, ...request.Option) *ec2.CreateTransitGatewayRouteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayRouteTableOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayRouteWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayRouteInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayRouteOutput, 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 *ec2.CreateTransitGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayRouteInput, ...request.Option) *ec2.CreateTransitGatewayRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayVpcAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayVpcAttachment(_a0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateTransitGatewayVpcAttachmentInput) *ec2.CreateTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayVpcAttachmentOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayVpcAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateTransitGatewayVpcAttachmentRequest(_a0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayVpcAttachmentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateTransitGatewayVpcAttachmentInput) *ec2.CreateTransitGatewayVpcAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateTransitGatewayVpcAttachmentOutput)
		}
	}

	return r0, r1
}

// CreateTransitGatewayVpcAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayVpcAttachmentWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayVpcAttachmentInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayVpcAttachmentOutput, 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 *ec2.CreateTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayVpcAttachmentInput, ...request.Option) *ec2.CreateTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayVpcAttachmentOutput)
		}
	}

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

	return r0, r1
}

// CreateTransitGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateTransitGatewayWithContext(_a0 context.Context, _a1 *ec2.CreateTransitGatewayInput, _a2 ...request.Option) (*ec2.CreateTransitGatewayOutput, 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 *ec2.CreateTransitGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayInput, ...request.Option) *ec2.CreateTransitGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateVolume provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVolume(_a0 *ec2.CreateVolumeInput) (*ec2.Volume, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.Volume
	if rf, ok := ret.Get(0).(func(*ec2.CreateVolumeInput) *ec2.Volume); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.Volume)
		}
	}

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

	return r0, r1
}

// CreateVolumeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVolumeRequest(_a0 *ec2.CreateVolumeInput) (*request.Request, *ec2.Volume) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.Volume
	if rf, ok := ret.Get(1).(func(*ec2.CreateVolumeInput) *ec2.Volume); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.Volume)
		}
	}

	return r0, r1
}

// CreateVolumeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVolumeWithContext(_a0 context.Context, _a1 *ec2.CreateVolumeInput, _a2 ...request.Option) (*ec2.Volume, 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 *ec2.Volume
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVolumeInput, ...request.Option) *ec2.Volume); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.Volume)
		}
	}

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

	return r0, r1
}

// CreateVpc provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpc(_a0 *ec2.CreateVpcInput) (*ec2.CreateVpcOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateVpcOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateVpcInput) *ec2.CreateVpcOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcEndpoint(_a0 *ec2.CreateVpcEndpointInput) (*ec2.CreateVpcEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateVpcEndpointOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateVpcEndpointInput) *ec2.CreateVpcEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcEndpointConnectionNotification provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcEndpointConnectionNotification(_a0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateVpcEndpointConnectionNotificationOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateVpcEndpointConnectionNotificationInput) *ec2.CreateVpcEndpointConnectionNotificationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointConnectionNotificationOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcEndpointConnectionNotificationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcEndpointConnectionNotificationRequest(_a0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.CreateVpcEndpointConnectionNotificationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateVpcEndpointConnectionNotificationOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateVpcEndpointConnectionNotificationInput) *ec2.CreateVpcEndpointConnectionNotificationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateVpcEndpointConnectionNotificationOutput)
		}
	}

	return r0, r1
}

// CreateVpcEndpointConnectionNotificationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVpcEndpointConnectionNotificationWithContext(_a0 context.Context, _a1 *ec2.CreateVpcEndpointConnectionNotificationInput, _a2 ...request.Option) (*ec2.CreateVpcEndpointConnectionNotificationOutput, 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 *ec2.CreateVpcEndpointConnectionNotificationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointConnectionNotificationInput, ...request.Option) *ec2.CreateVpcEndpointConnectionNotificationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointConnectionNotificationOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcEndpointRequest(_a0 *ec2.CreateVpcEndpointInput) (*request.Request, *ec2.CreateVpcEndpointOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateVpcEndpointOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateVpcEndpointInput) *ec2.CreateVpcEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateVpcEndpointOutput)
		}
	}

	return r0, r1
}

// CreateVpcEndpointServiceConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcEndpointServiceConfiguration(_a0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateVpcEndpointServiceConfigurationOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateVpcEndpointServiceConfigurationInput) *ec2.CreateVpcEndpointServiceConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointServiceConfigurationOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcEndpointServiceConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcEndpointServiceConfigurationRequest(_a0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.CreateVpcEndpointServiceConfigurationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateVpcEndpointServiceConfigurationOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateVpcEndpointServiceConfigurationInput) *ec2.CreateVpcEndpointServiceConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateVpcEndpointServiceConfigurationOutput)
		}
	}

	return r0, r1
}

// CreateVpcEndpointServiceConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVpcEndpointServiceConfigurationWithContext(_a0 context.Context, _a1 *ec2.CreateVpcEndpointServiceConfigurationInput, _a2 ...request.Option) (*ec2.CreateVpcEndpointServiceConfigurationOutput, 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 *ec2.CreateVpcEndpointServiceConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointServiceConfigurationInput, ...request.Option) *ec2.CreateVpcEndpointServiceConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointServiceConfigurationOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVpcEndpointWithContext(_a0 context.Context, _a1 *ec2.CreateVpcEndpointInput, _a2 ...request.Option) (*ec2.CreateVpcEndpointOutput, 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 *ec2.CreateVpcEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointInput, ...request.Option) *ec2.CreateVpcEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcPeeringConnection provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcPeeringConnection(_a0 *ec2.CreateVpcPeeringConnectionInput) (*ec2.CreateVpcPeeringConnectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateVpcPeeringConnectionOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateVpcPeeringConnectionInput) *ec2.CreateVpcPeeringConnectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcPeeringConnectionOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcPeeringConnectionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcPeeringConnectionRequest(_a0 *ec2.CreateVpcPeeringConnectionInput) (*request.Request, *ec2.CreateVpcPeeringConnectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateVpcPeeringConnectionOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateVpcPeeringConnectionInput) *ec2.CreateVpcPeeringConnectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateVpcPeeringConnectionOutput)
		}
	}

	return r0, r1
}

// CreateVpcPeeringConnectionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVpcPeeringConnectionWithContext(_a0 context.Context, _a1 *ec2.CreateVpcPeeringConnectionInput, _a2 ...request.Option) (*ec2.CreateVpcPeeringConnectionOutput, 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 *ec2.CreateVpcPeeringConnectionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcPeeringConnectionInput, ...request.Option) *ec2.CreateVpcPeeringConnectionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcPeeringConnectionOutput)
		}
	}

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

	return r0, r1
}

// CreateVpcRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpcRequest(_a0 *ec2.CreateVpcInput) (*request.Request, *ec2.CreateVpcOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateVpcOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateVpcInput) *ec2.CreateVpcOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateVpcOutput)
		}
	}

	return r0, r1
}

// CreateVpcWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVpcWithContext(_a0 context.Context, _a1 *ec2.CreateVpcInput, _a2 ...request.Option) (*ec2.CreateVpcOutput, 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 *ec2.CreateVpcOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcInput, ...request.Option) *ec2.CreateVpcOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcOutput)
		}
	}

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

	return r0, r1
}

// CreateVpnConnection provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpnConnection(_a0 *ec2.CreateVpnConnectionInput) (*ec2.CreateVpnConnectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateVpnConnectionOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateVpnConnectionInput) *ec2.CreateVpnConnectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnConnectionOutput)
		}
	}

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

	return r0, r1
}

// CreateVpnConnectionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpnConnectionRequest(_a0 *ec2.CreateVpnConnectionInput) (*request.Request, *ec2.CreateVpnConnectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateVpnConnectionOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateVpnConnectionInput) *ec2.CreateVpnConnectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateVpnConnectionOutput)
		}
	}

	return r0, r1
}

// CreateVpnConnectionRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpnConnectionRoute(_a0 *ec2.CreateVpnConnectionRouteInput) (*ec2.CreateVpnConnectionRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateVpnConnectionRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateVpnConnectionRouteInput) *ec2.CreateVpnConnectionRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnConnectionRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateVpnConnectionRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpnConnectionRouteRequest(_a0 *ec2.CreateVpnConnectionRouteInput) (*request.Request, *ec2.CreateVpnConnectionRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateVpnConnectionRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateVpnConnectionRouteInput) *ec2.CreateVpnConnectionRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateVpnConnectionRouteOutput)
		}
	}

	return r0, r1
}

// CreateVpnConnectionRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVpnConnectionRouteWithContext(_a0 context.Context, _a1 *ec2.CreateVpnConnectionRouteInput, _a2 ...request.Option) (*ec2.CreateVpnConnectionRouteOutput, 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 *ec2.CreateVpnConnectionRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConnectionRouteInput, ...request.Option) *ec2.CreateVpnConnectionRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnConnectionRouteOutput)
		}
	}

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

	return r0, r1
}

// CreateVpnConnectionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVpnConnectionWithContext(_a0 context.Context, _a1 *ec2.CreateVpnConnectionInput, _a2 ...request.Option) (*ec2.CreateVpnConnectionOutput, 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 *ec2.CreateVpnConnectionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConnectionInput, ...request.Option) *ec2.CreateVpnConnectionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnConnectionOutput)
		}
	}

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

	return r0, r1
}

// CreateVpnGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpnGateway(_a0 *ec2.CreateVpnGatewayInput) (*ec2.CreateVpnGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.CreateVpnGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.CreateVpnGatewayInput) *ec2.CreateVpnGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnGatewayOutput)
		}
	}

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

	return r0, r1
}

// CreateVpnGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) CreateVpnGatewayRequest(_a0 *ec2.CreateVpnGatewayInput) (*request.Request, *ec2.CreateVpnGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.CreateVpnGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.CreateVpnGatewayInput) *ec2.CreateVpnGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.CreateVpnGatewayOutput)
		}
	}

	return r0, r1
}

// CreateVpnGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) CreateVpnGatewayWithContext(_a0 context.Context, _a1 *ec2.CreateVpnGatewayInput, _a2 ...request.Option) (*ec2.CreateVpnGatewayOutput, 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 *ec2.CreateVpnGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnGatewayInput, ...request.Option) *ec2.CreateVpnGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteCarrierGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteCarrierGateway(_a0 *ec2.DeleteCarrierGatewayInput) (*ec2.DeleteCarrierGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteCarrierGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteCarrierGatewayInput) *ec2.DeleteCarrierGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCarrierGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteCarrierGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteCarrierGatewayRequest(_a0 *ec2.DeleteCarrierGatewayInput) (*request.Request, *ec2.DeleteCarrierGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteCarrierGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteCarrierGatewayInput) *ec2.DeleteCarrierGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteCarrierGatewayOutput)
		}
	}

	return r0, r1
}

// DeleteCarrierGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteCarrierGatewayWithContext(_a0 context.Context, _a1 *ec2.DeleteCarrierGatewayInput, _a2 ...request.Option) (*ec2.DeleteCarrierGatewayOutput, 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 *ec2.DeleteCarrierGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCarrierGatewayInput, ...request.Option) *ec2.DeleteCarrierGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCarrierGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteClientVpnEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteClientVpnEndpoint(_a0 *ec2.DeleteClientVpnEndpointInput) (*ec2.DeleteClientVpnEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteClientVpnEndpointOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteClientVpnEndpointInput) *ec2.DeleteClientVpnEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteClientVpnEndpointOutput)
		}
	}

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

	return r0, r1
}

// DeleteClientVpnEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteClientVpnEndpointRequest(_a0 *ec2.DeleteClientVpnEndpointInput) (*request.Request, *ec2.DeleteClientVpnEndpointOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteClientVpnEndpointOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteClientVpnEndpointInput) *ec2.DeleteClientVpnEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteClientVpnEndpointOutput)
		}
	}

	return r0, r1
}

// DeleteClientVpnEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteClientVpnEndpointWithContext(_a0 context.Context, _a1 *ec2.DeleteClientVpnEndpointInput, _a2 ...request.Option) (*ec2.DeleteClientVpnEndpointOutput, 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 *ec2.DeleteClientVpnEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteClientVpnEndpointInput, ...request.Option) *ec2.DeleteClientVpnEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteClientVpnEndpointOutput)
		}
	}

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

	return r0, r1
}

// DeleteClientVpnRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteClientVpnRoute(_a0 *ec2.DeleteClientVpnRouteInput) (*ec2.DeleteClientVpnRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteClientVpnRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteClientVpnRouteInput) *ec2.DeleteClientVpnRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteClientVpnRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteClientVpnRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteClientVpnRouteRequest(_a0 *ec2.DeleteClientVpnRouteInput) (*request.Request, *ec2.DeleteClientVpnRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteClientVpnRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteClientVpnRouteInput) *ec2.DeleteClientVpnRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteClientVpnRouteOutput)
		}
	}

	return r0, r1
}

// DeleteClientVpnRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteClientVpnRouteWithContext(_a0 context.Context, _a1 *ec2.DeleteClientVpnRouteInput, _a2 ...request.Option) (*ec2.DeleteClientVpnRouteOutput, 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 *ec2.DeleteClientVpnRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteClientVpnRouteInput, ...request.Option) *ec2.DeleteClientVpnRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteClientVpnRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteCustomerGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteCustomerGateway(_a0 *ec2.DeleteCustomerGatewayInput) (*ec2.DeleteCustomerGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteCustomerGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteCustomerGatewayInput) *ec2.DeleteCustomerGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCustomerGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteCustomerGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteCustomerGatewayRequest(_a0 *ec2.DeleteCustomerGatewayInput) (*request.Request, *ec2.DeleteCustomerGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteCustomerGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteCustomerGatewayInput) *ec2.DeleteCustomerGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteCustomerGatewayOutput)
		}
	}

	return r0, r1
}

// DeleteCustomerGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteCustomerGatewayWithContext(_a0 context.Context, _a1 *ec2.DeleteCustomerGatewayInput, _a2 ...request.Option) (*ec2.DeleteCustomerGatewayOutput, 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 *ec2.DeleteCustomerGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCustomerGatewayInput, ...request.Option) *ec2.DeleteCustomerGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCustomerGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteDhcpOptions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteDhcpOptions(_a0 *ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteDhcpOptionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteDhcpOptionsInput) *ec2.DeleteDhcpOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteDhcpOptionsOutput)
		}
	}

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

	return r0, r1
}

// DeleteDhcpOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteDhcpOptionsRequest(_a0 *ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteDhcpOptionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteDhcpOptionsInput) *ec2.DeleteDhcpOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteDhcpOptionsOutput)
		}
	}

	return r0, r1
}

// DeleteDhcpOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteDhcpOptionsWithContext(_a0 context.Context, _a1 *ec2.DeleteDhcpOptionsInput, _a2 ...request.Option) (*ec2.DeleteDhcpOptionsOutput, 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 *ec2.DeleteDhcpOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteDhcpOptionsInput, ...request.Option) *ec2.DeleteDhcpOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteDhcpOptionsOutput)
		}
	}

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

	return r0, r1
}

// DeleteEgressOnlyInternetGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteEgressOnlyInternetGateway(_a0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteEgressOnlyInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteEgressOnlyInternetGatewayInput) *ec2.DeleteEgressOnlyInternetGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteEgressOnlyInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteEgressOnlyInternetGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteEgressOnlyInternetGatewayRequest(_a0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*request.Request, *ec2.DeleteEgressOnlyInternetGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteEgressOnlyInternetGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteEgressOnlyInternetGatewayInput) *ec2.DeleteEgressOnlyInternetGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteEgressOnlyInternetGatewayOutput)
		}
	}

	return r0, r1
}

// DeleteEgressOnlyInternetGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteEgressOnlyInternetGatewayWithContext(_a0 context.Context, _a1 *ec2.DeleteEgressOnlyInternetGatewayInput, _a2 ...request.Option) (*ec2.DeleteEgressOnlyInternetGatewayOutput, 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 *ec2.DeleteEgressOnlyInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteEgressOnlyInternetGatewayInput, ...request.Option) *ec2.DeleteEgressOnlyInternetGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteEgressOnlyInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteFleets provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteFleets(_a0 *ec2.DeleteFleetsInput) (*ec2.DeleteFleetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteFleetsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteFleetsInput) *ec2.DeleteFleetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFleetsOutput)
		}
	}

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

	return r0, r1
}

// DeleteFleetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteFleetsRequest(_a0 *ec2.DeleteFleetsInput) (*request.Request, *ec2.DeleteFleetsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteFleetsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteFleetsInput) *ec2.DeleteFleetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteFleetsOutput)
		}
	}

	return r0, r1
}

// DeleteFleetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteFleetsWithContext(_a0 context.Context, _a1 *ec2.DeleteFleetsInput, _a2 ...request.Option) (*ec2.DeleteFleetsOutput, 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 *ec2.DeleteFleetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFleetsInput, ...request.Option) *ec2.DeleteFleetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFleetsOutput)
		}
	}

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

	return r0, r1
}

// DeleteFlowLogs provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteFlowLogs(_a0 *ec2.DeleteFlowLogsInput) (*ec2.DeleteFlowLogsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteFlowLogsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteFlowLogsInput) *ec2.DeleteFlowLogsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFlowLogsOutput)
		}
	}

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

	return r0, r1
}

// DeleteFlowLogsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteFlowLogsRequest(_a0 *ec2.DeleteFlowLogsInput) (*request.Request, *ec2.DeleteFlowLogsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteFlowLogsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteFlowLogsInput) *ec2.DeleteFlowLogsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteFlowLogsOutput)
		}
	}

	return r0, r1
}

// DeleteFlowLogsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteFlowLogsWithContext(_a0 context.Context, _a1 *ec2.DeleteFlowLogsInput, _a2 ...request.Option) (*ec2.DeleteFlowLogsOutput, 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 *ec2.DeleteFlowLogsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFlowLogsInput, ...request.Option) *ec2.DeleteFlowLogsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFlowLogsOutput)
		}
	}

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

	return r0, r1
}

// DeleteFpgaImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteFpgaImage(_a0 *ec2.DeleteFpgaImageInput) (*ec2.DeleteFpgaImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteFpgaImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteFpgaImageInput) *ec2.DeleteFpgaImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFpgaImageOutput)
		}
	}

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

	return r0, r1
}

// DeleteFpgaImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteFpgaImageRequest(_a0 *ec2.DeleteFpgaImageInput) (*request.Request, *ec2.DeleteFpgaImageOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteFpgaImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteFpgaImageInput) *ec2.DeleteFpgaImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteFpgaImageOutput)
		}
	}

	return r0, r1
}

// DeleteFpgaImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteFpgaImageWithContext(_a0 context.Context, _a1 *ec2.DeleteFpgaImageInput, _a2 ...request.Option) (*ec2.DeleteFpgaImageOutput, 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 *ec2.DeleteFpgaImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFpgaImageInput, ...request.Option) *ec2.DeleteFpgaImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFpgaImageOutput)
		}
	}

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

	return r0, r1
}

// DeleteInternetGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteInternetGateway(_a0 *ec2.DeleteInternetGatewayInput) (*ec2.DeleteInternetGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteInternetGatewayInput) *ec2.DeleteInternetGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteInternetGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteInternetGatewayRequest(_a0 *ec2.DeleteInternetGatewayInput) (*request.Request, *ec2.DeleteInternetGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteInternetGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteInternetGatewayInput) *ec2.DeleteInternetGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteInternetGatewayOutput)
		}
	}

	return r0, r1
}

// DeleteInternetGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteInternetGatewayWithContext(_a0 context.Context, _a1 *ec2.DeleteInternetGatewayInput, _a2 ...request.Option) (*ec2.DeleteInternetGatewayOutput, 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 *ec2.DeleteInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteInternetGatewayInput, ...request.Option) *ec2.DeleteInternetGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteInternetGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteKeyPair provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteKeyPair(_a0 *ec2.DeleteKeyPairInput) (*ec2.DeleteKeyPairOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteKeyPairOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteKeyPairInput) *ec2.DeleteKeyPairOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteKeyPairOutput)
		}
	}

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

	return r0, r1
}

// DeleteKeyPairRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteKeyPairRequest(_a0 *ec2.DeleteKeyPairInput) (*request.Request, *ec2.DeleteKeyPairOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteKeyPairOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteKeyPairInput) *ec2.DeleteKeyPairOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteKeyPairOutput)
		}
	}

	return r0, r1
}

// DeleteKeyPairWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteKeyPairWithContext(_a0 context.Context, _a1 *ec2.DeleteKeyPairInput, _a2 ...request.Option) (*ec2.DeleteKeyPairOutput, 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 *ec2.DeleteKeyPairOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteKeyPairInput, ...request.Option) *ec2.DeleteKeyPairOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteKeyPairOutput)
		}
	}

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

	return r0, r1
}

// DeleteLaunchTemplate provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteLaunchTemplate(_a0 *ec2.DeleteLaunchTemplateInput) (*ec2.DeleteLaunchTemplateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteLaunchTemplateOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteLaunchTemplateInput) *ec2.DeleteLaunchTemplateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLaunchTemplateOutput)
		}
	}

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

	return r0, r1
}

// DeleteLaunchTemplateRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteLaunchTemplateRequest(_a0 *ec2.DeleteLaunchTemplateInput) (*request.Request, *ec2.DeleteLaunchTemplateOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteLaunchTemplateOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteLaunchTemplateInput) *ec2.DeleteLaunchTemplateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteLaunchTemplateOutput)
		}
	}

	return r0, r1
}

// DeleteLaunchTemplateVersions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteLaunchTemplateVersions(_a0 *ec2.DeleteLaunchTemplateVersionsInput) (*ec2.DeleteLaunchTemplateVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteLaunchTemplateVersionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteLaunchTemplateVersionsInput) *ec2.DeleteLaunchTemplateVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLaunchTemplateVersionsOutput)
		}
	}

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

	return r0, r1
}

// DeleteLaunchTemplateVersionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteLaunchTemplateVersionsRequest(_a0 *ec2.DeleteLaunchTemplateVersionsInput) (*request.Request, *ec2.DeleteLaunchTemplateVersionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteLaunchTemplateVersionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteLaunchTemplateVersionsInput) *ec2.DeleteLaunchTemplateVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteLaunchTemplateVersionsOutput)
		}
	}

	return r0, r1
}

// DeleteLaunchTemplateVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteLaunchTemplateVersionsWithContext(_a0 context.Context, _a1 *ec2.DeleteLaunchTemplateVersionsInput, _a2 ...request.Option) (*ec2.DeleteLaunchTemplateVersionsOutput, 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 *ec2.DeleteLaunchTemplateVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLaunchTemplateVersionsInput, ...request.Option) *ec2.DeleteLaunchTemplateVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLaunchTemplateVersionsOutput)
		}
	}

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

	return r0, r1
}

// DeleteLaunchTemplateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteLaunchTemplateWithContext(_a0 context.Context, _a1 *ec2.DeleteLaunchTemplateInput, _a2 ...request.Option) (*ec2.DeleteLaunchTemplateOutput, 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 *ec2.DeleteLaunchTemplateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLaunchTemplateInput, ...request.Option) *ec2.DeleteLaunchTemplateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLaunchTemplateOutput)
		}
	}

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

	return r0, r1
}

// DeleteLocalGatewayRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteLocalGatewayRoute(_a0 *ec2.DeleteLocalGatewayRouteInput) (*ec2.DeleteLocalGatewayRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteLocalGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteLocalGatewayRouteInput) *ec2.DeleteLocalGatewayRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteLocalGatewayRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteLocalGatewayRouteRequest(_a0 *ec2.DeleteLocalGatewayRouteInput) (*request.Request, *ec2.DeleteLocalGatewayRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteLocalGatewayRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteLocalGatewayRouteInput) *ec2.DeleteLocalGatewayRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteLocalGatewayRouteOutput)
		}
	}

	return r0, r1
}

// DeleteLocalGatewayRouteTableVpcAssociation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteLocalGatewayRouteTableVpcAssociation(_a0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
		}
	}

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

	return r0, r1
}

// DeleteLocalGatewayRouteTableVpcAssociationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteLocalGatewayRouteTableVpcAssociationRequest(_a0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
		}
	}

	return r0, r1
}

// DeleteLocalGatewayRouteTableVpcAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteLocalGatewayRouteTableVpcAssociationWithContext(_a0 context.Context, _a1 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, _a2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, 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 *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, ...request.Option) *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
		}
	}

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

	return r0, r1
}

// DeleteLocalGatewayRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteLocalGatewayRouteWithContext(_a0 context.Context, _a1 *ec2.DeleteLocalGatewayRouteInput, _a2 ...request.Option) (*ec2.DeleteLocalGatewayRouteOutput, 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 *ec2.DeleteLocalGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteInput, ...request.Option) *ec2.DeleteLocalGatewayRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteManagedPrefixList provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteManagedPrefixList(_a0 *ec2.DeleteManagedPrefixListInput) (*ec2.DeleteManagedPrefixListOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteManagedPrefixListOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteManagedPrefixListInput) *ec2.DeleteManagedPrefixListOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteManagedPrefixListOutput)
		}
	}

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

	return r0, r1
}

// DeleteManagedPrefixListRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteManagedPrefixListRequest(_a0 *ec2.DeleteManagedPrefixListInput) (*request.Request, *ec2.DeleteManagedPrefixListOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteManagedPrefixListOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteManagedPrefixListInput) *ec2.DeleteManagedPrefixListOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteManagedPrefixListOutput)
		}
	}

	return r0, r1
}

// DeleteManagedPrefixListWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteManagedPrefixListWithContext(_a0 context.Context, _a1 *ec2.DeleteManagedPrefixListInput, _a2 ...request.Option) (*ec2.DeleteManagedPrefixListOutput, 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 *ec2.DeleteManagedPrefixListOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteManagedPrefixListInput, ...request.Option) *ec2.DeleteManagedPrefixListOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteManagedPrefixListOutput)
		}
	}

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

	return r0, r1
}

// DeleteNatGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNatGateway(_a0 *ec2.DeleteNatGatewayInput) (*ec2.DeleteNatGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteNatGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteNatGatewayInput) *ec2.DeleteNatGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNatGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteNatGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNatGatewayRequest(_a0 *ec2.DeleteNatGatewayInput) (*request.Request, *ec2.DeleteNatGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteNatGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteNatGatewayInput) *ec2.DeleteNatGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteNatGatewayOutput)
		}
	}

	return r0, r1
}

// DeleteNatGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteNatGatewayWithContext(_a0 context.Context, _a1 *ec2.DeleteNatGatewayInput, _a2 ...request.Option) (*ec2.DeleteNatGatewayOutput, 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 *ec2.DeleteNatGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNatGatewayInput, ...request.Option) *ec2.DeleteNatGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNatGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkAcl provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkAcl(_a0 *ec2.DeleteNetworkAclInput) (*ec2.DeleteNetworkAclOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteNetworkAclOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteNetworkAclInput) *ec2.DeleteNetworkAclOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkAclOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkAclEntry provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkAclEntry(_a0 *ec2.DeleteNetworkAclEntryInput) (*ec2.DeleteNetworkAclEntryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteNetworkAclEntryOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteNetworkAclEntryInput) *ec2.DeleteNetworkAclEntryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkAclEntryOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkAclEntryRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkAclEntryRequest(_a0 *ec2.DeleteNetworkAclEntryInput) (*request.Request, *ec2.DeleteNetworkAclEntryOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteNetworkAclEntryOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteNetworkAclEntryInput) *ec2.DeleteNetworkAclEntryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteNetworkAclEntryOutput)
		}
	}

	return r0, r1
}

// DeleteNetworkAclEntryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteNetworkAclEntryWithContext(_a0 context.Context, _a1 *ec2.DeleteNetworkAclEntryInput, _a2 ...request.Option) (*ec2.DeleteNetworkAclEntryOutput, 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 *ec2.DeleteNetworkAclEntryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkAclEntryInput, ...request.Option) *ec2.DeleteNetworkAclEntryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkAclEntryOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkAclRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkAclRequest(_a0 *ec2.DeleteNetworkAclInput) (*request.Request, *ec2.DeleteNetworkAclOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteNetworkAclOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteNetworkAclInput) *ec2.DeleteNetworkAclOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteNetworkAclOutput)
		}
	}

	return r0, r1
}

// DeleteNetworkAclWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteNetworkAclWithContext(_a0 context.Context, _a1 *ec2.DeleteNetworkAclInput, _a2 ...request.Option) (*ec2.DeleteNetworkAclOutput, 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 *ec2.DeleteNetworkAclOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkAclInput, ...request.Option) *ec2.DeleteNetworkAclOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkAclOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkInsightsAnalysis provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkInsightsAnalysis(_a0 *ec2.DeleteNetworkInsightsAnalysisInput) (*ec2.DeleteNetworkInsightsAnalysisOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteNetworkInsightsAnalysisOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteNetworkInsightsAnalysisInput) *ec2.DeleteNetworkInsightsAnalysisOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInsightsAnalysisOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkInsightsAnalysisRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkInsightsAnalysisRequest(_a0 *ec2.DeleteNetworkInsightsAnalysisInput) (*request.Request, *ec2.DeleteNetworkInsightsAnalysisOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteNetworkInsightsAnalysisOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteNetworkInsightsAnalysisInput) *ec2.DeleteNetworkInsightsAnalysisOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteNetworkInsightsAnalysisOutput)
		}
	}

	return r0, r1
}

// DeleteNetworkInsightsAnalysisWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteNetworkInsightsAnalysisWithContext(_a0 context.Context, _a1 *ec2.DeleteNetworkInsightsAnalysisInput, _a2 ...request.Option) (*ec2.DeleteNetworkInsightsAnalysisOutput, 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 *ec2.DeleteNetworkInsightsAnalysisOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsAnalysisInput, ...request.Option) *ec2.DeleteNetworkInsightsAnalysisOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInsightsAnalysisOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkInsightsPath provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkInsightsPath(_a0 *ec2.DeleteNetworkInsightsPathInput) (*ec2.DeleteNetworkInsightsPathOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteNetworkInsightsPathOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteNetworkInsightsPathInput) *ec2.DeleteNetworkInsightsPathOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInsightsPathOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkInsightsPathRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkInsightsPathRequest(_a0 *ec2.DeleteNetworkInsightsPathInput) (*request.Request, *ec2.DeleteNetworkInsightsPathOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteNetworkInsightsPathOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteNetworkInsightsPathInput) *ec2.DeleteNetworkInsightsPathOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteNetworkInsightsPathOutput)
		}
	}

	return r0, r1
}

// DeleteNetworkInsightsPathWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteNetworkInsightsPathWithContext(_a0 context.Context, _a1 *ec2.DeleteNetworkInsightsPathInput, _a2 ...request.Option) (*ec2.DeleteNetworkInsightsPathOutput, 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 *ec2.DeleteNetworkInsightsPathOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsPathInput, ...request.Option) *ec2.DeleteNetworkInsightsPathOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInsightsPathOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkInterface provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkInterface(_a0 *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteNetworkInterfaceOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteNetworkInterfaceInput) *ec2.DeleteNetworkInterfaceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInterfaceOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkInterfacePermission provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkInterfacePermission(_a0 *ec2.DeleteNetworkInterfacePermissionInput) (*ec2.DeleteNetworkInterfacePermissionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteNetworkInterfacePermissionOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteNetworkInterfacePermissionInput) *ec2.DeleteNetworkInterfacePermissionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInterfacePermissionOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkInterfacePermissionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkInterfacePermissionRequest(_a0 *ec2.DeleteNetworkInterfacePermissionInput) (*request.Request, *ec2.DeleteNetworkInterfacePermissionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteNetworkInterfacePermissionOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteNetworkInterfacePermissionInput) *ec2.DeleteNetworkInterfacePermissionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteNetworkInterfacePermissionOutput)
		}
	}

	return r0, r1
}

// DeleteNetworkInterfacePermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteNetworkInterfacePermissionWithContext(_a0 context.Context, _a1 *ec2.DeleteNetworkInterfacePermissionInput, _a2 ...request.Option) (*ec2.DeleteNetworkInterfacePermissionOutput, 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 *ec2.DeleteNetworkInterfacePermissionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInterfacePermissionInput, ...request.Option) *ec2.DeleteNetworkInterfacePermissionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInterfacePermissionOutput)
		}
	}

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

	return r0, r1
}

// DeleteNetworkInterfaceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteNetworkInterfaceRequest(_a0 *ec2.DeleteNetworkInterfaceInput) (*request.Request, *ec2.DeleteNetworkInterfaceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteNetworkInterfaceOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteNetworkInterfaceInput) *ec2.DeleteNetworkInterfaceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteNetworkInterfaceOutput)
		}
	}

	return r0, r1
}

// DeleteNetworkInterfaceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteNetworkInterfaceWithContext(_a0 context.Context, _a1 *ec2.DeleteNetworkInterfaceInput, _a2 ...request.Option) (*ec2.DeleteNetworkInterfaceOutput, 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 *ec2.DeleteNetworkInterfaceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInterfaceInput, ...request.Option) *ec2.DeleteNetworkInterfaceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInterfaceOutput)
		}
	}

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

	return r0, r1
}

// DeletePlacementGroup provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeletePlacementGroup(_a0 *ec2.DeletePlacementGroupInput) (*ec2.DeletePlacementGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeletePlacementGroupOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeletePlacementGroupInput) *ec2.DeletePlacementGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeletePlacementGroupOutput)
		}
	}

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

	return r0, r1
}

// DeletePlacementGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeletePlacementGroupRequest(_a0 *ec2.DeletePlacementGroupInput) (*request.Request, *ec2.DeletePlacementGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeletePlacementGroupOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeletePlacementGroupInput) *ec2.DeletePlacementGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeletePlacementGroupOutput)
		}
	}

	return r0, r1
}

// DeletePlacementGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeletePlacementGroupWithContext(_a0 context.Context, _a1 *ec2.DeletePlacementGroupInput, _a2 ...request.Option) (*ec2.DeletePlacementGroupOutput, 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 *ec2.DeletePlacementGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeletePlacementGroupInput, ...request.Option) *ec2.DeletePlacementGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeletePlacementGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteQueuedReservedInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteQueuedReservedInstances(_a0 *ec2.DeleteQueuedReservedInstancesInput) (*ec2.DeleteQueuedReservedInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteQueuedReservedInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteQueuedReservedInstancesInput) *ec2.DeleteQueuedReservedInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteQueuedReservedInstancesOutput)
		}
	}

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

	return r0, r1
}

// DeleteQueuedReservedInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteQueuedReservedInstancesRequest(_a0 *ec2.DeleteQueuedReservedInstancesInput) (*request.Request, *ec2.DeleteQueuedReservedInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteQueuedReservedInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteQueuedReservedInstancesInput) *ec2.DeleteQueuedReservedInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteQueuedReservedInstancesOutput)
		}
	}

	return r0, r1
}

// DeleteQueuedReservedInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteQueuedReservedInstancesWithContext(_a0 context.Context, _a1 *ec2.DeleteQueuedReservedInstancesInput, _a2 ...request.Option) (*ec2.DeleteQueuedReservedInstancesOutput, 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 *ec2.DeleteQueuedReservedInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteQueuedReservedInstancesInput, ...request.Option) *ec2.DeleteQueuedReservedInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteQueuedReservedInstancesOutput)
		}
	}

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

	return r0, r1
}

// DeleteRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteRoute(_a0 *ec2.DeleteRouteInput) (*ec2.DeleteRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteRouteInput) *ec2.DeleteRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteRouteRequest(_a0 *ec2.DeleteRouteInput) (*request.Request, *ec2.DeleteRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteRouteInput) *ec2.DeleteRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteRouteOutput)
		}
	}

	return r0, r1
}

// DeleteRouteTable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteRouteTable(_a0 *ec2.DeleteRouteTableInput) (*ec2.DeleteRouteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteRouteTableOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteRouteTableInput) *ec2.DeleteRouteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteTableOutput)
		}
	}

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

	return r0, r1
}

// DeleteRouteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteRouteTableRequest(_a0 *ec2.DeleteRouteTableInput) (*request.Request, *ec2.DeleteRouteTableOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteRouteTableOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteRouteTableInput) *ec2.DeleteRouteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteRouteTableOutput)
		}
	}

	return r0, r1
}

// DeleteRouteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteRouteTableWithContext(_a0 context.Context, _a1 *ec2.DeleteRouteTableInput, _a2 ...request.Option) (*ec2.DeleteRouteTableOutput, 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 *ec2.DeleteRouteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteTableInput, ...request.Option) *ec2.DeleteRouteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteTableOutput)
		}
	}

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

	return r0, r1
}

// DeleteRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteRouteWithContext(_a0 context.Context, _a1 *ec2.DeleteRouteInput, _a2 ...request.Option) (*ec2.DeleteRouteOutput, 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 *ec2.DeleteRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteInput, ...request.Option) *ec2.DeleteRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteSecurityGroup provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteSecurityGroup(_a0 *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteSecurityGroupInput) *ec2.DeleteSecurityGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteSecurityGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteSecurityGroupRequest(_a0 *ec2.DeleteSecurityGroupInput) (*request.Request, *ec2.DeleteSecurityGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteSecurityGroupOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteSecurityGroupInput) *ec2.DeleteSecurityGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteSecurityGroupOutput)
		}
	}

	return r0, r1
}

// DeleteSecurityGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteSecurityGroupWithContext(_a0 context.Context, _a1 *ec2.DeleteSecurityGroupInput, _a2 ...request.Option) (*ec2.DeleteSecurityGroupOutput, 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 *ec2.DeleteSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSecurityGroupInput, ...request.Option) *ec2.DeleteSecurityGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteSnapshot(_a0 *ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteSnapshotOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteSnapshotInput) *ec2.DeleteSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSnapshotOutput)
		}
	}

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

	return r0, r1
}

// DeleteSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteSnapshotRequest(_a0 *ec2.DeleteSnapshotInput) (*request.Request, *ec2.DeleteSnapshotOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteSnapshotOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteSnapshotInput) *ec2.DeleteSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteSnapshotOutput)
		}
	}

	return r0, r1
}

// DeleteSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteSnapshotWithContext(_a0 context.Context, _a1 *ec2.DeleteSnapshotInput, _a2 ...request.Option) (*ec2.DeleteSnapshotOutput, 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 *ec2.DeleteSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSnapshotInput, ...request.Option) *ec2.DeleteSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSnapshotOutput)
		}
	}

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

	return r0, r1
}

// DeleteSpotDatafeedSubscription provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteSpotDatafeedSubscription(_a0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteSpotDatafeedSubscriptionInput) *ec2.DeleteSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSpotDatafeedSubscriptionOutput)
		}
	}

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

	return r0, r1
}

// DeleteSpotDatafeedSubscriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteSpotDatafeedSubscriptionRequest(_a0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteSpotDatafeedSubscriptionInput) *ec2.DeleteSpotDatafeedSubscriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteSpotDatafeedSubscriptionOutput)
		}
	}

	return r0, r1
}

// DeleteSpotDatafeedSubscriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteSpotDatafeedSubscriptionWithContext(_a0 context.Context, _a1 *ec2.DeleteSpotDatafeedSubscriptionInput, _a2 ...request.Option) (*ec2.DeleteSpotDatafeedSubscriptionOutput, 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 *ec2.DeleteSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSpotDatafeedSubscriptionInput, ...request.Option) *ec2.DeleteSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSpotDatafeedSubscriptionOutput)
		}
	}

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

	return r0, r1
}

// DeleteSubnet provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteSubnet(_a0 *ec2.DeleteSubnetInput) (*ec2.DeleteSubnetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteSubnetOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteSubnetInput) *ec2.DeleteSubnetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSubnetOutput)
		}
	}

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

	return r0, r1
}

// DeleteSubnetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteSubnetRequest(_a0 *ec2.DeleteSubnetInput) (*request.Request, *ec2.DeleteSubnetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteSubnetOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteSubnetInput) *ec2.DeleteSubnetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteSubnetOutput)
		}
	}

	return r0, r1
}

// DeleteSubnetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteSubnetWithContext(_a0 context.Context, _a1 *ec2.DeleteSubnetInput, _a2 ...request.Option) (*ec2.DeleteSubnetOutput, 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 *ec2.DeleteSubnetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSubnetInput, ...request.Option) *ec2.DeleteSubnetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSubnetOutput)
		}
	}

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

	return r0, r1
}

// DeleteTags provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTags(_a0 *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTagsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTagsInput) *ec2.DeleteTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTagsOutput)
		}
	}

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

	return r0, r1
}

// DeleteTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTagsRequest(_a0 *ec2.DeleteTagsInput) (*request.Request, *ec2.DeleteTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTagsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTagsInput) *ec2.DeleteTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTagsOutput)
		}
	}

	return r0, r1
}

// DeleteTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTagsWithContext(_a0 context.Context, _a1 *ec2.DeleteTagsInput, _a2 ...request.Option) (*ec2.DeleteTagsOutput, 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 *ec2.DeleteTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTagsInput, ...request.Option) *ec2.DeleteTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTagsOutput)
		}
	}

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

	return r0, r1
}

// DeleteTrafficMirrorFilter provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTrafficMirrorFilter(_a0 *ec2.DeleteTrafficMirrorFilterInput) (*ec2.DeleteTrafficMirrorFilterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTrafficMirrorFilterOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTrafficMirrorFilterInput) *ec2.DeleteTrafficMirrorFilterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorFilterOutput)
		}
	}

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

	return r0, r1
}

// DeleteTrafficMirrorFilterRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTrafficMirrorFilterRequest(_a0 *ec2.DeleteTrafficMirrorFilterInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTrafficMirrorFilterOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTrafficMirrorFilterInput) *ec2.DeleteTrafficMirrorFilterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTrafficMirrorFilterOutput)
		}
	}

	return r0, r1
}

// DeleteTrafficMirrorFilterRule provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTrafficMirrorFilterRule(_a0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTrafficMirrorFilterRuleInput) *ec2.DeleteTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorFilterRuleOutput)
		}
	}

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

	return r0, r1
}

// DeleteTrafficMirrorFilterRuleRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTrafficMirrorFilterRuleRequest(_a0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterRuleOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTrafficMirrorFilterRuleInput) *ec2.DeleteTrafficMirrorFilterRuleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTrafficMirrorFilterRuleOutput)
		}
	}

	return r0, r1
}

// DeleteTrafficMirrorFilterRuleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTrafficMirrorFilterRuleWithContext(_a0 context.Context, _a1 *ec2.DeleteTrafficMirrorFilterRuleInput, _a2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterRuleOutput, 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 *ec2.DeleteTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorFilterRuleInput, ...request.Option) *ec2.DeleteTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorFilterRuleOutput)
		}
	}

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

	return r0, r1
}

// DeleteTrafficMirrorFilterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTrafficMirrorFilterWithContext(_a0 context.Context, _a1 *ec2.DeleteTrafficMirrorFilterInput, _a2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterOutput, 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 *ec2.DeleteTrafficMirrorFilterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorFilterInput, ...request.Option) *ec2.DeleteTrafficMirrorFilterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorFilterOutput)
		}
	}

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

	return r0, r1
}

// DeleteTrafficMirrorSession provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTrafficMirrorSession(_a0 *ec2.DeleteTrafficMirrorSessionInput) (*ec2.DeleteTrafficMirrorSessionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTrafficMirrorSessionOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTrafficMirrorSessionInput) *ec2.DeleteTrafficMirrorSessionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorSessionOutput)
		}
	}

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

	return r0, r1
}

// DeleteTrafficMirrorSessionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTrafficMirrorSessionRequest(_a0 *ec2.DeleteTrafficMirrorSessionInput) (*request.Request, *ec2.DeleteTrafficMirrorSessionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTrafficMirrorSessionOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTrafficMirrorSessionInput) *ec2.DeleteTrafficMirrorSessionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTrafficMirrorSessionOutput)
		}
	}

	return r0, r1
}

// DeleteTrafficMirrorSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTrafficMirrorSessionWithContext(_a0 context.Context, _a1 *ec2.DeleteTrafficMirrorSessionInput, _a2 ...request.Option) (*ec2.DeleteTrafficMirrorSessionOutput, 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 *ec2.DeleteTrafficMirrorSessionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorSessionInput, ...request.Option) *ec2.DeleteTrafficMirrorSessionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorSessionOutput)
		}
	}

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

	return r0, r1
}

// DeleteTrafficMirrorTarget provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTrafficMirrorTarget(_a0 *ec2.DeleteTrafficMirrorTargetInput) (*ec2.DeleteTrafficMirrorTargetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTrafficMirrorTargetOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTrafficMirrorTargetInput) *ec2.DeleteTrafficMirrorTargetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorTargetOutput)
		}
	}

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

	return r0, r1
}

// DeleteTrafficMirrorTargetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTrafficMirrorTargetRequest(_a0 *ec2.DeleteTrafficMirrorTargetInput) (*request.Request, *ec2.DeleteTrafficMirrorTargetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTrafficMirrorTargetOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTrafficMirrorTargetInput) *ec2.DeleteTrafficMirrorTargetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTrafficMirrorTargetOutput)
		}
	}

	return r0, r1
}

// DeleteTrafficMirrorTargetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTrafficMirrorTargetWithContext(_a0 context.Context, _a1 *ec2.DeleteTrafficMirrorTargetInput, _a2 ...request.Option) (*ec2.DeleteTrafficMirrorTargetOutput, 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 *ec2.DeleteTrafficMirrorTargetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorTargetInput, ...request.Option) *ec2.DeleteTrafficMirrorTargetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorTargetOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGateway(_a0 *ec2.DeleteTransitGatewayInput) (*ec2.DeleteTransitGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayInput) *ec2.DeleteTransitGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayConnect provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayConnect(_a0 *ec2.DeleteTransitGatewayConnectInput) (*ec2.DeleteTransitGatewayConnectOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayConnectOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayConnectInput) *ec2.DeleteTransitGatewayConnectOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayConnectOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayConnectPeer provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayConnectPeer(_a0 *ec2.DeleteTransitGatewayConnectPeerInput) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayConnectPeerOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayConnectPeerInput) *ec2.DeleteTransitGatewayConnectPeerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayConnectPeerOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayConnectPeerRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayConnectPeerRequest(_a0 *ec2.DeleteTransitGatewayConnectPeerInput) (*request.Request, *ec2.DeleteTransitGatewayConnectPeerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayConnectPeerOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayConnectPeerInput) *ec2.DeleteTransitGatewayConnectPeerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayConnectPeerOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayConnectPeerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayConnectPeerWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayConnectPeerInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayConnectPeerOutput, 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 *ec2.DeleteTransitGatewayConnectPeerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayConnectPeerInput, ...request.Option) *ec2.DeleteTransitGatewayConnectPeerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayConnectPeerOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayConnectRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayConnectRequest(_a0 *ec2.DeleteTransitGatewayConnectInput) (*request.Request, *ec2.DeleteTransitGatewayConnectOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayConnectOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayConnectInput) *ec2.DeleteTransitGatewayConnectOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayConnectOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayConnectWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayConnectWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayConnectInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayConnectOutput, 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 *ec2.DeleteTransitGatewayConnectOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayConnectInput, ...request.Option) *ec2.DeleteTransitGatewayConnectOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayConnectOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayMulticastDomain provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayMulticastDomain(_a0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayMulticastDomainInput) *ec2.DeleteTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayMulticastDomainOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayMulticastDomainRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayMulticastDomainRequest(_a0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DeleteTransitGatewayMulticastDomainOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayMulticastDomainInput) *ec2.DeleteTransitGatewayMulticastDomainOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayMulticastDomainOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayMulticastDomainWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayMulticastDomainWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayMulticastDomainInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayMulticastDomainOutput, 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 *ec2.DeleteTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMulticastDomainInput, ...request.Option) *ec2.DeleteTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayMulticastDomainOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayPeeringAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayPeeringAttachment(_a0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayPeeringAttachmentInput) *ec2.DeleteTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayPeeringAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayPeeringAttachmentRequest(_a0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayPeeringAttachmentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayPeeringAttachmentInput) *ec2.DeleteTransitGatewayPeeringAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayPeeringAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayPeeringAttachmentWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayPeeringAttachmentInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, 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 *ec2.DeleteTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayPeeringAttachmentInput, ...request.Option) *ec2.DeleteTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayPrefixListReference provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayPrefixListReference(_a0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayPrefixListReferenceInput) *ec2.DeleteTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayPrefixListReferenceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayPrefixListReferenceRequest(_a0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.DeleteTransitGatewayPrefixListReferenceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayPrefixListReferenceInput) *ec2.DeleteTransitGatewayPrefixListReferenceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayPrefixListReferenceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayPrefixListReferenceWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayPrefixListReferenceInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, 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 *ec2.DeleteTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayPrefixListReferenceInput, ...request.Option) *ec2.DeleteTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayRequest(_a0 *ec2.DeleteTransitGatewayInput) (*request.Request, *ec2.DeleteTransitGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayInput) *ec2.DeleteTransitGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayRoute(_a0 *ec2.DeleteTransitGatewayRouteInput) (*ec2.DeleteTransitGatewayRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayRouteInput) *ec2.DeleteTransitGatewayRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayRouteRequest(_a0 *ec2.DeleteTransitGatewayRouteInput) (*request.Request, *ec2.DeleteTransitGatewayRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayRouteInput) *ec2.DeleteTransitGatewayRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayRouteOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayRouteTable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayRouteTable(_a0 *ec2.DeleteTransitGatewayRouteTableInput) (*ec2.DeleteTransitGatewayRouteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayRouteTableInput) *ec2.DeleteTransitGatewayRouteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayRouteTableOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayRouteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayRouteTableRequest(_a0 *ec2.DeleteTransitGatewayRouteTableInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayRouteTableInput) *ec2.DeleteTransitGatewayRouteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayRouteTableOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayRouteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayRouteTableWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayRouteTableInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableOutput, 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 *ec2.DeleteTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayRouteTableInput, ...request.Option) *ec2.DeleteTransitGatewayRouteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayRouteTableOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayRouteWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayRouteInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayRouteOutput, 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 *ec2.DeleteTransitGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayRouteInput, ...request.Option) *ec2.DeleteTransitGatewayRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayVpcAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayVpcAttachment(_a0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteTransitGatewayVpcAttachmentInput) *ec2.DeleteTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayVpcAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteTransitGatewayVpcAttachmentRequest(_a0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayVpcAttachmentOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteTransitGatewayVpcAttachmentInput) *ec2.DeleteTransitGatewayVpcAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
		}
	}

	return r0, r1
}

// DeleteTransitGatewayVpcAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayVpcAttachmentWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayVpcAttachmentInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, 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 *ec2.DeleteTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayVpcAttachmentInput, ...request.Option) *ec2.DeleteTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
		}
	}

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

	return r0, r1
}

// DeleteTransitGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteTransitGatewayWithContext(_a0 context.Context, _a1 *ec2.DeleteTransitGatewayInput, _a2 ...request.Option) (*ec2.DeleteTransitGatewayOutput, 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 *ec2.DeleteTransitGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayInput, ...request.Option) *ec2.DeleteTransitGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteVolume provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVolume(_a0 *ec2.DeleteVolumeInput) (*ec2.DeleteVolumeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVolumeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVolumeInput) *ec2.DeleteVolumeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVolumeOutput)
		}
	}

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

	return r0, r1
}

// DeleteVolumeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVolumeRequest(_a0 *ec2.DeleteVolumeInput) (*request.Request, *ec2.DeleteVolumeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVolumeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVolumeInput) *ec2.DeleteVolumeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVolumeOutput)
		}
	}

	return r0, r1
}

// DeleteVolumeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVolumeWithContext(_a0 context.Context, _a1 *ec2.DeleteVolumeInput, _a2 ...request.Option) (*ec2.DeleteVolumeOutput, 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 *ec2.DeleteVolumeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVolumeInput, ...request.Option) *ec2.DeleteVolumeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVolumeOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpc provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpc(_a0 *ec2.DeleteVpcInput) (*ec2.DeleteVpcOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVpcOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVpcInput) *ec2.DeleteVpcOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcEndpointConnectionNotifications provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcEndpointConnectionNotifications(_a0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVpcEndpointConnectionNotificationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVpcEndpointConnectionNotificationsInput) *ec2.DeleteVpcEndpointConnectionNotificationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcEndpointConnectionNotificationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcEndpointConnectionNotificationsRequest(_a0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DeleteVpcEndpointConnectionNotificationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVpcEndpointConnectionNotificationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVpcEndpointConnectionNotificationsInput) *ec2.DeleteVpcEndpointConnectionNotificationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
		}
	}

	return r0, r1
}

// DeleteVpcEndpointConnectionNotificationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVpcEndpointConnectionNotificationsWithContext(_a0 context.Context, _a1 *ec2.DeleteVpcEndpointConnectionNotificationsInput, _a2 ...request.Option) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, 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 *ec2.DeleteVpcEndpointConnectionNotificationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointConnectionNotificationsInput, ...request.Option) *ec2.DeleteVpcEndpointConnectionNotificationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcEndpointServiceConfigurations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcEndpointServiceConfigurations(_a0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVpcEndpointServiceConfigurationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVpcEndpointServiceConfigurationsInput) *ec2.DeleteVpcEndpointServiceConfigurationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcEndpointServiceConfigurationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcEndpointServiceConfigurationsRequest(_a0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DeleteVpcEndpointServiceConfigurationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVpcEndpointServiceConfigurationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVpcEndpointServiceConfigurationsInput) *ec2.DeleteVpcEndpointServiceConfigurationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
		}
	}

	return r0, r1
}

// DeleteVpcEndpointServiceConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVpcEndpointServiceConfigurationsWithContext(_a0 context.Context, _a1 *ec2.DeleteVpcEndpointServiceConfigurationsInput, _a2 ...request.Option) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, 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 *ec2.DeleteVpcEndpointServiceConfigurationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointServiceConfigurationsInput, ...request.Option) *ec2.DeleteVpcEndpointServiceConfigurationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcEndpoints provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcEndpoints(_a0 *ec2.DeleteVpcEndpointsInput) (*ec2.DeleteVpcEndpointsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVpcEndpointsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVpcEndpointsInput) *ec2.DeleteVpcEndpointsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointsOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcEndpointsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcEndpointsRequest(_a0 *ec2.DeleteVpcEndpointsInput) (*request.Request, *ec2.DeleteVpcEndpointsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVpcEndpointsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVpcEndpointsInput) *ec2.DeleteVpcEndpointsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVpcEndpointsOutput)
		}
	}

	return r0, r1
}

// DeleteVpcEndpointsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVpcEndpointsWithContext(_a0 context.Context, _a1 *ec2.DeleteVpcEndpointsInput, _a2 ...request.Option) (*ec2.DeleteVpcEndpointsOutput, 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 *ec2.DeleteVpcEndpointsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointsInput, ...request.Option) *ec2.DeleteVpcEndpointsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointsOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcPeeringConnection provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcPeeringConnection(_a0 *ec2.DeleteVpcPeeringConnectionInput) (*ec2.DeleteVpcPeeringConnectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVpcPeeringConnectionOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVpcPeeringConnectionInput) *ec2.DeleteVpcPeeringConnectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcPeeringConnectionOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcPeeringConnectionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcPeeringConnectionRequest(_a0 *ec2.DeleteVpcPeeringConnectionInput) (*request.Request, *ec2.DeleteVpcPeeringConnectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVpcPeeringConnectionOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVpcPeeringConnectionInput) *ec2.DeleteVpcPeeringConnectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVpcPeeringConnectionOutput)
		}
	}

	return r0, r1
}

// DeleteVpcPeeringConnectionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVpcPeeringConnectionWithContext(_a0 context.Context, _a1 *ec2.DeleteVpcPeeringConnectionInput, _a2 ...request.Option) (*ec2.DeleteVpcPeeringConnectionOutput, 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 *ec2.DeleteVpcPeeringConnectionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcPeeringConnectionInput, ...request.Option) *ec2.DeleteVpcPeeringConnectionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcPeeringConnectionOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpcRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpcRequest(_a0 *ec2.DeleteVpcInput) (*request.Request, *ec2.DeleteVpcOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVpcOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVpcInput) *ec2.DeleteVpcOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVpcOutput)
		}
	}

	return r0, r1
}

// DeleteVpcWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVpcWithContext(_a0 context.Context, _a1 *ec2.DeleteVpcInput, _a2 ...request.Option) (*ec2.DeleteVpcOutput, 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 *ec2.DeleteVpcOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcInput, ...request.Option) *ec2.DeleteVpcOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpnConnection provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpnConnection(_a0 *ec2.DeleteVpnConnectionInput) (*ec2.DeleteVpnConnectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVpnConnectionOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVpnConnectionInput) *ec2.DeleteVpnConnectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnConnectionOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpnConnectionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpnConnectionRequest(_a0 *ec2.DeleteVpnConnectionInput) (*request.Request, *ec2.DeleteVpnConnectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVpnConnectionOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVpnConnectionInput) *ec2.DeleteVpnConnectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVpnConnectionOutput)
		}
	}

	return r0, r1
}

// DeleteVpnConnectionRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpnConnectionRoute(_a0 *ec2.DeleteVpnConnectionRouteInput) (*ec2.DeleteVpnConnectionRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVpnConnectionRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVpnConnectionRouteInput) *ec2.DeleteVpnConnectionRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnConnectionRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpnConnectionRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpnConnectionRouteRequest(_a0 *ec2.DeleteVpnConnectionRouteInput) (*request.Request, *ec2.DeleteVpnConnectionRouteOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVpnConnectionRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVpnConnectionRouteInput) *ec2.DeleteVpnConnectionRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVpnConnectionRouteOutput)
		}
	}

	return r0, r1
}

// DeleteVpnConnectionRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVpnConnectionRouteWithContext(_a0 context.Context, _a1 *ec2.DeleteVpnConnectionRouteInput, _a2 ...request.Option) (*ec2.DeleteVpnConnectionRouteOutput, 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 *ec2.DeleteVpnConnectionRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConnectionRouteInput, ...request.Option) *ec2.DeleteVpnConnectionRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnConnectionRouteOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpnConnectionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVpnConnectionWithContext(_a0 context.Context, _a1 *ec2.DeleteVpnConnectionInput, _a2 ...request.Option) (*ec2.DeleteVpnConnectionOutput, 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 *ec2.DeleteVpnConnectionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConnectionInput, ...request.Option) *ec2.DeleteVpnConnectionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnConnectionOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpnGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpnGateway(_a0 *ec2.DeleteVpnGatewayInput) (*ec2.DeleteVpnGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeleteVpnGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeleteVpnGatewayInput) *ec2.DeleteVpnGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeleteVpnGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeleteVpnGatewayRequest(_a0 *ec2.DeleteVpnGatewayInput) (*request.Request, *ec2.DeleteVpnGatewayOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeleteVpnGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeleteVpnGatewayInput) *ec2.DeleteVpnGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeleteVpnGatewayOutput)
		}
	}

	return r0, r1
}

// DeleteVpnGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeleteVpnGatewayWithContext(_a0 context.Context, _a1 *ec2.DeleteVpnGatewayInput, _a2 ...request.Option) (*ec2.DeleteVpnGatewayOutput, 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 *ec2.DeleteVpnGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnGatewayInput, ...request.Option) *ec2.DeleteVpnGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnGatewayOutput)
		}
	}

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

	return r0, r1
}

// DeprovisionByoipCidr provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeprovisionByoipCidr(_a0 *ec2.DeprovisionByoipCidrInput) (*ec2.DeprovisionByoipCidrOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeprovisionByoipCidrOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeprovisionByoipCidrInput) *ec2.DeprovisionByoipCidrOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeprovisionByoipCidrOutput)
		}
	}

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

	return r0, r1
}

// DeprovisionByoipCidrRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeprovisionByoipCidrRequest(_a0 *ec2.DeprovisionByoipCidrInput) (*request.Request, *ec2.DeprovisionByoipCidrOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeprovisionByoipCidrOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeprovisionByoipCidrInput) *ec2.DeprovisionByoipCidrOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeprovisionByoipCidrOutput)
		}
	}

	return r0, r1
}

// DeprovisionByoipCidrWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeprovisionByoipCidrWithContext(_a0 context.Context, _a1 *ec2.DeprovisionByoipCidrInput, _a2 ...request.Option) (*ec2.DeprovisionByoipCidrOutput, 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 *ec2.DeprovisionByoipCidrOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionByoipCidrInput, ...request.Option) *ec2.DeprovisionByoipCidrOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeprovisionByoipCidrOutput)
		}
	}

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

	return r0, r1
}

// DeregisterImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeregisterImage(_a0 *ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeregisterImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeregisterImageInput) *ec2.DeregisterImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterImageOutput)
		}
	}

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

	return r0, r1
}

// DeregisterImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeregisterImageRequest(_a0 *ec2.DeregisterImageInput) (*request.Request, *ec2.DeregisterImageOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeregisterImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeregisterImageInput) *ec2.DeregisterImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeregisterImageOutput)
		}
	}

	return r0, r1
}

// DeregisterImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeregisterImageWithContext(_a0 context.Context, _a1 *ec2.DeregisterImageInput, _a2 ...request.Option) (*ec2.DeregisterImageOutput, 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 *ec2.DeregisterImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterImageInput, ...request.Option) *ec2.DeregisterImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterImageOutput)
		}
	}

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

	return r0, r1
}

// DeregisterInstanceEventNotificationAttributes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeregisterInstanceEventNotificationAttributes(_a0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeregisterInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeregisterInstanceEventNotificationAttributesInput) *ec2.DeregisterInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
		}
	}

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

	return r0, r1
}

// DeregisterInstanceEventNotificationAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeregisterInstanceEventNotificationAttributesRequest(_a0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DeregisterInstanceEventNotificationAttributesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeregisterInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeregisterInstanceEventNotificationAttributesInput) *ec2.DeregisterInstanceEventNotificationAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
		}
	}

	return r0, r1
}

// DeregisterInstanceEventNotificationAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeregisterInstanceEventNotificationAttributesWithContext(_a0 context.Context, _a1 *ec2.DeregisterInstanceEventNotificationAttributesInput, _a2 ...request.Option) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, 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 *ec2.DeregisterInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterInstanceEventNotificationAttributesInput, ...request.Option) *ec2.DeregisterInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTransitGatewayMulticastGroupMembers provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeregisterTransitGatewayMulticastGroupMembers(_a0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeregisterTransitGatewayMulticastGroupMembersInput) *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTransitGatewayMulticastGroupMembersRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeregisterTransitGatewayMulticastGroupMembersRequest(_a0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeregisterTransitGatewayMulticastGroupMembersInput) *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
		}
	}

	return r0, r1
}

// DeregisterTransitGatewayMulticastGroupMembersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeregisterTransitGatewayMulticastGroupMembersWithContext(_a0 context.Context, _a1 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, _a2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, 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 *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, ...request.Option) *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTransitGatewayMulticastGroupSources provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeregisterTransitGatewayMulticastGroupSources(_a0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTransitGatewayMulticastGroupSourcesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DeregisterTransitGatewayMulticastGroupSourcesRequest(_a0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
		}
	}

	return r0, r1
}

// DeregisterTransitGatewayMulticastGroupSourcesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DeregisterTransitGatewayMulticastGroupSourcesWithContext(_a0 context.Context, _a1 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, _a2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, 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 *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, ...request.Option) *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAccountAttributes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAccountAttributes(_a0 *ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeAccountAttributesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeAccountAttributesInput) *ec2.DescribeAccountAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAccountAttributesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAccountAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAccountAttributesRequest(_a0 *ec2.DescribeAccountAttributesInput) (*request.Request, *ec2.DescribeAccountAttributesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeAccountAttributesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeAccountAttributesInput) *ec2.DescribeAccountAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeAccountAttributesOutput)
		}
	}

	return r0, r1
}

// DescribeAccountAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeAccountAttributesWithContext(_a0 context.Context, _a1 *ec2.DescribeAccountAttributesInput, _a2 ...request.Option) (*ec2.DescribeAccountAttributesOutput, 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 *ec2.DescribeAccountAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAccountAttributesInput, ...request.Option) *ec2.DescribeAccountAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAccountAttributesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAddresses provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAddresses(_a0 *ec2.DescribeAddressesInput) (*ec2.DescribeAddressesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeAddressesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeAddressesInput) *ec2.DescribeAddressesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAddressesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAddressesAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAddressesAttribute(_a0 *ec2.DescribeAddressesAttributeInput) (*ec2.DescribeAddressesAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeAddressesAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeAddressesAttributeInput) *ec2.DescribeAddressesAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAddressesAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeAddressesAttributePages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeAddressesAttributePages(_a0 *ec2.DescribeAddressesAttributeInput, _a1 func(*ec2.DescribeAddressesAttributeOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeAddressesAttributePagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeAddressesAttributePagesWithContext(_a0 context.Context, _a1 *ec2.DescribeAddressesAttributeInput, _a2 func(*ec2.DescribeAddressesAttributeOutput, 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, *ec2.DescribeAddressesAttributeInput, func(*ec2.DescribeAddressesAttributeOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeAddressesAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAddressesAttributeRequest(_a0 *ec2.DescribeAddressesAttributeInput) (*request.Request, *ec2.DescribeAddressesAttributeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeAddressesAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeAddressesAttributeInput) *ec2.DescribeAddressesAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeAddressesAttributeOutput)
		}
	}

	return r0, r1
}

// DescribeAddressesAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeAddressesAttributeWithContext(_a0 context.Context, _a1 *ec2.DescribeAddressesAttributeInput, _a2 ...request.Option) (*ec2.DescribeAddressesAttributeOutput, 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 *ec2.DescribeAddressesAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAddressesAttributeInput, ...request.Option) *ec2.DescribeAddressesAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAddressesAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeAddressesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAddressesRequest(_a0 *ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeAddressesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeAddressesInput) *ec2.DescribeAddressesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeAddressesOutput)
		}
	}

	return r0, r1
}

// DescribeAddressesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeAddressesWithContext(_a0 context.Context, _a1 *ec2.DescribeAddressesInput, _a2 ...request.Option) (*ec2.DescribeAddressesOutput, 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 *ec2.DescribeAddressesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAddressesInput, ...request.Option) *ec2.DescribeAddressesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAddressesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAggregateIdFormat provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAggregateIdFormat(_a0 *ec2.DescribeAggregateIdFormatInput) (*ec2.DescribeAggregateIdFormatOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeAggregateIdFormatOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeAggregateIdFormatInput) *ec2.DescribeAggregateIdFormatOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAggregateIdFormatOutput)
		}
	}

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

	return r0, r1
}

// DescribeAggregateIdFormatRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAggregateIdFormatRequest(_a0 *ec2.DescribeAggregateIdFormatInput) (*request.Request, *ec2.DescribeAggregateIdFormatOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeAggregateIdFormatOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeAggregateIdFormatInput) *ec2.DescribeAggregateIdFormatOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeAggregateIdFormatOutput)
		}
	}

	return r0, r1
}

// DescribeAggregateIdFormatWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeAggregateIdFormatWithContext(_a0 context.Context, _a1 *ec2.DescribeAggregateIdFormatInput, _a2 ...request.Option) (*ec2.DescribeAggregateIdFormatOutput, 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 *ec2.DescribeAggregateIdFormatOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAggregateIdFormatInput, ...request.Option) *ec2.DescribeAggregateIdFormatOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAggregateIdFormatOutput)
		}
	}

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

	return r0, r1
}

// DescribeAvailabilityZones provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAvailabilityZones(_a0 *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeAvailabilityZonesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeAvailabilityZonesInput) *ec2.DescribeAvailabilityZonesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAvailabilityZonesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAvailabilityZonesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeAvailabilityZonesRequest(_a0 *ec2.DescribeAvailabilityZonesInput) (*request.Request, *ec2.DescribeAvailabilityZonesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeAvailabilityZonesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeAvailabilityZonesInput) *ec2.DescribeAvailabilityZonesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeAvailabilityZonesOutput)
		}
	}

	return r0, r1
}

// DescribeAvailabilityZonesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeAvailabilityZonesWithContext(_a0 context.Context, _a1 *ec2.DescribeAvailabilityZonesInput, _a2 ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, 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 *ec2.DescribeAvailabilityZonesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAvailabilityZonesInput, ...request.Option) *ec2.DescribeAvailabilityZonesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAvailabilityZonesOutput)
		}
	}

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

	return r0, r1
}

// DescribeBundleTasks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeBundleTasks(_a0 *ec2.DescribeBundleTasksInput) (*ec2.DescribeBundleTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeBundleTasksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeBundleTasksInput) *ec2.DescribeBundleTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeBundleTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeBundleTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeBundleTasksRequest(_a0 *ec2.DescribeBundleTasksInput) (*request.Request, *ec2.DescribeBundleTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeBundleTasksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeBundleTasksInput) *ec2.DescribeBundleTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeBundleTasksOutput)
		}
	}

	return r0, r1
}

// DescribeBundleTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeBundleTasksWithContext(_a0 context.Context, _a1 *ec2.DescribeBundleTasksInput, _a2 ...request.Option) (*ec2.DescribeBundleTasksOutput, 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 *ec2.DescribeBundleTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeBundleTasksInput, ...request.Option) *ec2.DescribeBundleTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeBundleTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeByoipCidrs provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeByoipCidrs(_a0 *ec2.DescribeByoipCidrsInput) (*ec2.DescribeByoipCidrsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeByoipCidrsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeByoipCidrsInput) *ec2.DescribeByoipCidrsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeByoipCidrsOutput)
		}
	}

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

	return r0, r1
}

// DescribeByoipCidrsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeByoipCidrsPages(_a0 *ec2.DescribeByoipCidrsInput, _a1 func(*ec2.DescribeByoipCidrsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeByoipCidrsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeByoipCidrsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeByoipCidrsInput, _a2 func(*ec2.DescribeByoipCidrsOutput, 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, *ec2.DescribeByoipCidrsInput, func(*ec2.DescribeByoipCidrsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeByoipCidrsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeByoipCidrsRequest(_a0 *ec2.DescribeByoipCidrsInput) (*request.Request, *ec2.DescribeByoipCidrsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeByoipCidrsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeByoipCidrsInput) *ec2.DescribeByoipCidrsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeByoipCidrsOutput)
		}
	}

	return r0, r1
}

// DescribeByoipCidrsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeByoipCidrsWithContext(_a0 context.Context, _a1 *ec2.DescribeByoipCidrsInput, _a2 ...request.Option) (*ec2.DescribeByoipCidrsOutput, 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 *ec2.DescribeByoipCidrsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeByoipCidrsInput, ...request.Option) *ec2.DescribeByoipCidrsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeByoipCidrsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCapacityReservations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeCapacityReservations(_a0 *ec2.DescribeCapacityReservationsInput) (*ec2.DescribeCapacityReservationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeCapacityReservationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeCapacityReservationsInput) *ec2.DescribeCapacityReservationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityReservationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCapacityReservationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeCapacityReservationsPages(_a0 *ec2.DescribeCapacityReservationsInput, _a1 func(*ec2.DescribeCapacityReservationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCapacityReservationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeCapacityReservationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeCapacityReservationsInput, _a2 func(*ec2.DescribeCapacityReservationsOutput, 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, *ec2.DescribeCapacityReservationsInput, func(*ec2.DescribeCapacityReservationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCapacityReservationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeCapacityReservationsRequest(_a0 *ec2.DescribeCapacityReservationsInput) (*request.Request, *ec2.DescribeCapacityReservationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeCapacityReservationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeCapacityReservationsInput) *ec2.DescribeCapacityReservationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeCapacityReservationsOutput)
		}
	}

	return r0, r1
}

// DescribeCapacityReservationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeCapacityReservationsWithContext(_a0 context.Context, _a1 *ec2.DescribeCapacityReservationsInput, _a2 ...request.Option) (*ec2.DescribeCapacityReservationsOutput, 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 *ec2.DescribeCapacityReservationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationsInput, ...request.Option) *ec2.DescribeCapacityReservationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityReservationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCarrierGateways provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeCarrierGateways(_a0 *ec2.DescribeCarrierGatewaysInput) (*ec2.DescribeCarrierGatewaysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeCarrierGatewaysOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeCarrierGatewaysInput) *ec2.DescribeCarrierGatewaysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCarrierGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeCarrierGatewaysPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeCarrierGatewaysPages(_a0 *ec2.DescribeCarrierGatewaysInput, _a1 func(*ec2.DescribeCarrierGatewaysOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCarrierGatewaysPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeCarrierGatewaysPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeCarrierGatewaysInput, _a2 func(*ec2.DescribeCarrierGatewaysOutput, 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, *ec2.DescribeCarrierGatewaysInput, func(*ec2.DescribeCarrierGatewaysOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCarrierGatewaysRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeCarrierGatewaysRequest(_a0 *ec2.DescribeCarrierGatewaysInput) (*request.Request, *ec2.DescribeCarrierGatewaysOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeCarrierGatewaysOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeCarrierGatewaysInput) *ec2.DescribeCarrierGatewaysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeCarrierGatewaysOutput)
		}
	}

	return r0, r1
}

// DescribeCarrierGatewaysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeCarrierGatewaysWithContext(_a0 context.Context, _a1 *ec2.DescribeCarrierGatewaysInput, _a2 ...request.Option) (*ec2.DescribeCarrierGatewaysOutput, 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 *ec2.DescribeCarrierGatewaysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCarrierGatewaysInput, ...request.Option) *ec2.DescribeCarrierGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCarrierGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeClassicLinkInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClassicLinkInstances(_a0 *ec2.DescribeClassicLinkInstancesInput) (*ec2.DescribeClassicLinkInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeClassicLinkInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeClassicLinkInstancesInput) *ec2.DescribeClassicLinkInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClassicLinkInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeClassicLinkInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeClassicLinkInstancesPages(_a0 *ec2.DescribeClassicLinkInstancesInput, _a1 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeClassicLinkInstancesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeClassicLinkInstancesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeClassicLinkInstancesInput, _a2 func(*ec2.DescribeClassicLinkInstancesOutput, 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, *ec2.DescribeClassicLinkInstancesInput, func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeClassicLinkInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClassicLinkInstancesRequest(_a0 *ec2.DescribeClassicLinkInstancesInput) (*request.Request, *ec2.DescribeClassicLinkInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeClassicLinkInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeClassicLinkInstancesInput) *ec2.DescribeClassicLinkInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeClassicLinkInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeClassicLinkInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeClassicLinkInstancesWithContext(_a0 context.Context, _a1 *ec2.DescribeClassicLinkInstancesInput, _a2 ...request.Option) (*ec2.DescribeClassicLinkInstancesOutput, 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 *ec2.DescribeClassicLinkInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClassicLinkInstancesInput, ...request.Option) *ec2.DescribeClassicLinkInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClassicLinkInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnAuthorizationRules provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnAuthorizationRules(_a0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeClientVpnAuthorizationRulesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeClientVpnAuthorizationRulesInput) *ec2.DescribeClientVpnAuthorizationRulesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnAuthorizationRulesOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnAuthorizationRulesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeClientVpnAuthorizationRulesPages(_a0 *ec2.DescribeClientVpnAuthorizationRulesInput, _a1 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeClientVpnAuthorizationRulesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeClientVpnAuthorizationRulesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnAuthorizationRulesInput, _a2 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, 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, *ec2.DescribeClientVpnAuthorizationRulesInput, func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeClientVpnAuthorizationRulesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnAuthorizationRulesRequest(_a0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*request.Request, *ec2.DescribeClientVpnAuthorizationRulesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeClientVpnAuthorizationRulesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeClientVpnAuthorizationRulesInput) *ec2.DescribeClientVpnAuthorizationRulesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeClientVpnAuthorizationRulesOutput)
		}
	}

	return r0, r1
}

// DescribeClientVpnAuthorizationRulesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeClientVpnAuthorizationRulesWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnAuthorizationRulesInput, _a2 ...request.Option) (*ec2.DescribeClientVpnAuthorizationRulesOutput, 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 *ec2.DescribeClientVpnAuthorizationRulesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnAuthorizationRulesInput, ...request.Option) *ec2.DescribeClientVpnAuthorizationRulesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnAuthorizationRulesOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnConnections provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnConnections(_a0 *ec2.DescribeClientVpnConnectionsInput) (*ec2.DescribeClientVpnConnectionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeClientVpnConnectionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeClientVpnConnectionsInput) *ec2.DescribeClientVpnConnectionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnConnectionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnConnectionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeClientVpnConnectionsPages(_a0 *ec2.DescribeClientVpnConnectionsInput, _a1 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeClientVpnConnectionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeClientVpnConnectionsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnConnectionsInput, _a2 func(*ec2.DescribeClientVpnConnectionsOutput, 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, *ec2.DescribeClientVpnConnectionsInput, func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeClientVpnConnectionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnConnectionsRequest(_a0 *ec2.DescribeClientVpnConnectionsInput) (*request.Request, *ec2.DescribeClientVpnConnectionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeClientVpnConnectionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeClientVpnConnectionsInput) *ec2.DescribeClientVpnConnectionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeClientVpnConnectionsOutput)
		}
	}

	return r0, r1
}

// DescribeClientVpnConnectionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeClientVpnConnectionsWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnConnectionsInput, _a2 ...request.Option) (*ec2.DescribeClientVpnConnectionsOutput, 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 *ec2.DescribeClientVpnConnectionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnConnectionsInput, ...request.Option) *ec2.DescribeClientVpnConnectionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnConnectionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnEndpoints provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnEndpoints(_a0 *ec2.DescribeClientVpnEndpointsInput) (*ec2.DescribeClientVpnEndpointsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeClientVpnEndpointsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeClientVpnEndpointsInput) *ec2.DescribeClientVpnEndpointsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnEndpointsOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnEndpointsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeClientVpnEndpointsPages(_a0 *ec2.DescribeClientVpnEndpointsInput, _a1 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeClientVpnEndpointsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeClientVpnEndpointsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnEndpointsInput, _a2 func(*ec2.DescribeClientVpnEndpointsOutput, 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, *ec2.DescribeClientVpnEndpointsInput, func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeClientVpnEndpointsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnEndpointsRequest(_a0 *ec2.DescribeClientVpnEndpointsInput) (*request.Request, *ec2.DescribeClientVpnEndpointsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeClientVpnEndpointsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeClientVpnEndpointsInput) *ec2.DescribeClientVpnEndpointsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeClientVpnEndpointsOutput)
		}
	}

	return r0, r1
}

// DescribeClientVpnEndpointsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeClientVpnEndpointsWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnEndpointsInput, _a2 ...request.Option) (*ec2.DescribeClientVpnEndpointsOutput, 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 *ec2.DescribeClientVpnEndpointsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnEndpointsInput, ...request.Option) *ec2.DescribeClientVpnEndpointsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnEndpointsOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnRoutes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnRoutes(_a0 *ec2.DescribeClientVpnRoutesInput) (*ec2.DescribeClientVpnRoutesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeClientVpnRoutesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeClientVpnRoutesInput) *ec2.DescribeClientVpnRoutesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnRoutesOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnRoutesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeClientVpnRoutesPages(_a0 *ec2.DescribeClientVpnRoutesInput, _a1 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeClientVpnRoutesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeClientVpnRoutesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnRoutesInput, _a2 func(*ec2.DescribeClientVpnRoutesOutput, 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, *ec2.DescribeClientVpnRoutesInput, func(*ec2.DescribeClientVpnRoutesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeClientVpnRoutesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnRoutesRequest(_a0 *ec2.DescribeClientVpnRoutesInput) (*request.Request, *ec2.DescribeClientVpnRoutesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeClientVpnRoutesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeClientVpnRoutesInput) *ec2.DescribeClientVpnRoutesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeClientVpnRoutesOutput)
		}
	}

	return r0, r1
}

// DescribeClientVpnRoutesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeClientVpnRoutesWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnRoutesInput, _a2 ...request.Option) (*ec2.DescribeClientVpnRoutesOutput, 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 *ec2.DescribeClientVpnRoutesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnRoutesInput, ...request.Option) *ec2.DescribeClientVpnRoutesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnRoutesOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnTargetNetworks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnTargetNetworks(_a0 *ec2.DescribeClientVpnTargetNetworksInput) (*ec2.DescribeClientVpnTargetNetworksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeClientVpnTargetNetworksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeClientVpnTargetNetworksInput) *ec2.DescribeClientVpnTargetNetworksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnTargetNetworksOutput)
		}
	}

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

	return r0, r1
}

// DescribeClientVpnTargetNetworksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeClientVpnTargetNetworksPages(_a0 *ec2.DescribeClientVpnTargetNetworksInput, _a1 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeClientVpnTargetNetworksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeClientVpnTargetNetworksPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnTargetNetworksInput, _a2 func(*ec2.DescribeClientVpnTargetNetworksOutput, 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, *ec2.DescribeClientVpnTargetNetworksInput, func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeClientVpnTargetNetworksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeClientVpnTargetNetworksRequest(_a0 *ec2.DescribeClientVpnTargetNetworksInput) (*request.Request, *ec2.DescribeClientVpnTargetNetworksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeClientVpnTargetNetworksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeClientVpnTargetNetworksInput) *ec2.DescribeClientVpnTargetNetworksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeClientVpnTargetNetworksOutput)
		}
	}

	return r0, r1
}

// DescribeClientVpnTargetNetworksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeClientVpnTargetNetworksWithContext(_a0 context.Context, _a1 *ec2.DescribeClientVpnTargetNetworksInput, _a2 ...request.Option) (*ec2.DescribeClientVpnTargetNetworksOutput, 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 *ec2.DescribeClientVpnTargetNetworksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnTargetNetworksInput, ...request.Option) *ec2.DescribeClientVpnTargetNetworksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnTargetNetworksOutput)
		}
	}

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

	return r0, r1
}

// DescribeCoipPools provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeCoipPools(_a0 *ec2.DescribeCoipPoolsInput) (*ec2.DescribeCoipPoolsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeCoipPoolsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeCoipPoolsInput) *ec2.DescribeCoipPoolsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCoipPoolsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCoipPoolsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeCoipPoolsPages(_a0 *ec2.DescribeCoipPoolsInput, _a1 func(*ec2.DescribeCoipPoolsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCoipPoolsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeCoipPoolsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeCoipPoolsInput, _a2 func(*ec2.DescribeCoipPoolsOutput, 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, *ec2.DescribeCoipPoolsInput, func(*ec2.DescribeCoipPoolsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCoipPoolsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeCoipPoolsRequest(_a0 *ec2.DescribeCoipPoolsInput) (*request.Request, *ec2.DescribeCoipPoolsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeCoipPoolsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeCoipPoolsInput) *ec2.DescribeCoipPoolsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeCoipPoolsOutput)
		}
	}

	return r0, r1
}

// DescribeCoipPoolsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeCoipPoolsWithContext(_a0 context.Context, _a1 *ec2.DescribeCoipPoolsInput, _a2 ...request.Option) (*ec2.DescribeCoipPoolsOutput, 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 *ec2.DescribeCoipPoolsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCoipPoolsInput, ...request.Option) *ec2.DescribeCoipPoolsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCoipPoolsOutput)
		}
	}

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

	return r0, r1
}

// DescribeConversionTasks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeConversionTasks(_a0 *ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeConversionTasksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeConversionTasksInput) *ec2.DescribeConversionTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeConversionTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeConversionTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeConversionTasksRequest(_a0 *ec2.DescribeConversionTasksInput) (*request.Request, *ec2.DescribeConversionTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeConversionTasksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeConversionTasksInput) *ec2.DescribeConversionTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeConversionTasksOutput)
		}
	}

	return r0, r1
}

// DescribeConversionTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeConversionTasksWithContext(_a0 context.Context, _a1 *ec2.DescribeConversionTasksInput, _a2 ...request.Option) (*ec2.DescribeConversionTasksOutput, 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 *ec2.DescribeConversionTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeConversionTasksInput, ...request.Option) *ec2.DescribeConversionTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeConversionTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeCustomerGateways provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeCustomerGateways(_a0 *ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeCustomerGatewaysOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeCustomerGatewaysInput) *ec2.DescribeCustomerGatewaysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCustomerGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeCustomerGatewaysRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeCustomerGatewaysRequest(_a0 *ec2.DescribeCustomerGatewaysInput) (*request.Request, *ec2.DescribeCustomerGatewaysOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeCustomerGatewaysOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeCustomerGatewaysInput) *ec2.DescribeCustomerGatewaysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeCustomerGatewaysOutput)
		}
	}

	return r0, r1
}

// DescribeCustomerGatewaysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeCustomerGatewaysWithContext(_a0 context.Context, _a1 *ec2.DescribeCustomerGatewaysInput, _a2 ...request.Option) (*ec2.DescribeCustomerGatewaysOutput, 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 *ec2.DescribeCustomerGatewaysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCustomerGatewaysInput, ...request.Option) *ec2.DescribeCustomerGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCustomerGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeDhcpOptions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeDhcpOptions(_a0 *ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeDhcpOptionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeDhcpOptionsInput) *ec2.DescribeDhcpOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeDhcpOptionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeDhcpOptionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeDhcpOptionsPages(_a0 *ec2.DescribeDhcpOptionsInput, _a1 func(*ec2.DescribeDhcpOptionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeDhcpOptionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeDhcpOptionsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeDhcpOptionsInput, _a2 func(*ec2.DescribeDhcpOptionsOutput, 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, *ec2.DescribeDhcpOptionsInput, func(*ec2.DescribeDhcpOptionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDhcpOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeDhcpOptionsRequest(_a0 *ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeDhcpOptionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeDhcpOptionsInput) *ec2.DescribeDhcpOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeDhcpOptionsOutput)
		}
	}

	return r0, r1
}

// DescribeDhcpOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeDhcpOptionsWithContext(_a0 context.Context, _a1 *ec2.DescribeDhcpOptionsInput, _a2 ...request.Option) (*ec2.DescribeDhcpOptionsOutput, 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 *ec2.DescribeDhcpOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeDhcpOptionsInput, ...request.Option) *ec2.DescribeDhcpOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeDhcpOptionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeEgressOnlyInternetGateways provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeEgressOnlyInternetGateways(_a0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeEgressOnlyInternetGatewaysOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeEgressOnlyInternetGatewaysInput) *ec2.DescribeEgressOnlyInternetGatewaysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeEgressOnlyInternetGatewaysPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeEgressOnlyInternetGatewaysPages(_a0 *ec2.DescribeEgressOnlyInternetGatewaysInput, _a1 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeEgressOnlyInternetGatewaysPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeEgressOnlyInternetGatewaysPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeEgressOnlyInternetGatewaysInput, _a2 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, 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, *ec2.DescribeEgressOnlyInternetGatewaysInput, func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeEgressOnlyInternetGatewaysRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeEgressOnlyInternetGatewaysRequest(_a0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*request.Request, *ec2.DescribeEgressOnlyInternetGatewaysOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeEgressOnlyInternetGatewaysOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeEgressOnlyInternetGatewaysInput) *ec2.DescribeEgressOnlyInternetGatewaysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
		}
	}

	return r0, r1
}

// DescribeEgressOnlyInternetGatewaysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeEgressOnlyInternetGatewaysWithContext(_a0 context.Context, _a1 *ec2.DescribeEgressOnlyInternetGatewaysInput, _a2 ...request.Option) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, 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 *ec2.DescribeEgressOnlyInternetGatewaysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeEgressOnlyInternetGatewaysInput, ...request.Option) *ec2.DescribeEgressOnlyInternetGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeElasticGpus provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeElasticGpus(_a0 *ec2.DescribeElasticGpusInput) (*ec2.DescribeElasticGpusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeElasticGpusOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeElasticGpusInput) *ec2.DescribeElasticGpusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeElasticGpusOutput)
		}
	}

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

	return r0, r1
}

// DescribeElasticGpusRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeElasticGpusRequest(_a0 *ec2.DescribeElasticGpusInput) (*request.Request, *ec2.DescribeElasticGpusOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeElasticGpusOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeElasticGpusInput) *ec2.DescribeElasticGpusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeElasticGpusOutput)
		}
	}

	return r0, r1
}

// DescribeElasticGpusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeElasticGpusWithContext(_a0 context.Context, _a1 *ec2.DescribeElasticGpusInput, _a2 ...request.Option) (*ec2.DescribeElasticGpusOutput, 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 *ec2.DescribeElasticGpusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeElasticGpusInput, ...request.Option) *ec2.DescribeElasticGpusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeElasticGpusOutput)
		}
	}

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

	return r0, r1
}

// DescribeExportImageTasks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeExportImageTasks(_a0 *ec2.DescribeExportImageTasksInput) (*ec2.DescribeExportImageTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeExportImageTasksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeExportImageTasksInput) *ec2.DescribeExportImageTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeExportImageTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeExportImageTasksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeExportImageTasksPages(_a0 *ec2.DescribeExportImageTasksInput, _a1 func(*ec2.DescribeExportImageTasksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeExportImageTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeExportImageTasksPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeExportImageTasksInput, _a2 func(*ec2.DescribeExportImageTasksOutput, 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, *ec2.DescribeExportImageTasksInput, func(*ec2.DescribeExportImageTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeExportImageTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeExportImageTasksRequest(_a0 *ec2.DescribeExportImageTasksInput) (*request.Request, *ec2.DescribeExportImageTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeExportImageTasksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeExportImageTasksInput) *ec2.DescribeExportImageTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeExportImageTasksOutput)
		}
	}

	return r0, r1
}

// DescribeExportImageTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeExportImageTasksWithContext(_a0 context.Context, _a1 *ec2.DescribeExportImageTasksInput, _a2 ...request.Option) (*ec2.DescribeExportImageTasksOutput, 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 *ec2.DescribeExportImageTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeExportImageTasksInput, ...request.Option) *ec2.DescribeExportImageTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeExportImageTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeExportTasks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeExportTasks(_a0 *ec2.DescribeExportTasksInput) (*ec2.DescribeExportTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeExportTasksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeExportTasksInput) *ec2.DescribeExportTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeExportTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeExportTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeExportTasksRequest(_a0 *ec2.DescribeExportTasksInput) (*request.Request, *ec2.DescribeExportTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeExportTasksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeExportTasksInput) *ec2.DescribeExportTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeExportTasksOutput)
		}
	}

	return r0, r1
}

// DescribeExportTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeExportTasksWithContext(_a0 context.Context, _a1 *ec2.DescribeExportTasksInput, _a2 ...request.Option) (*ec2.DescribeExportTasksOutput, 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 *ec2.DescribeExportTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeExportTasksInput, ...request.Option) *ec2.DescribeExportTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeExportTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeFastSnapshotRestores provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFastSnapshotRestores(_a0 *ec2.DescribeFastSnapshotRestoresInput) (*ec2.DescribeFastSnapshotRestoresOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeFastSnapshotRestoresOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeFastSnapshotRestoresInput) *ec2.DescribeFastSnapshotRestoresOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFastSnapshotRestoresOutput)
		}
	}

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

	return r0, r1
}

// DescribeFastSnapshotRestoresPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeFastSnapshotRestoresPages(_a0 *ec2.DescribeFastSnapshotRestoresInput, _a1 func(*ec2.DescribeFastSnapshotRestoresOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeFastSnapshotRestoresPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeFastSnapshotRestoresPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeFastSnapshotRestoresInput, _a2 func(*ec2.DescribeFastSnapshotRestoresOutput, 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, *ec2.DescribeFastSnapshotRestoresInput, func(*ec2.DescribeFastSnapshotRestoresOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeFastSnapshotRestoresRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFastSnapshotRestoresRequest(_a0 *ec2.DescribeFastSnapshotRestoresInput) (*request.Request, *ec2.DescribeFastSnapshotRestoresOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeFastSnapshotRestoresOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeFastSnapshotRestoresInput) *ec2.DescribeFastSnapshotRestoresOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeFastSnapshotRestoresOutput)
		}
	}

	return r0, r1
}

// DescribeFastSnapshotRestoresWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeFastSnapshotRestoresWithContext(_a0 context.Context, _a1 *ec2.DescribeFastSnapshotRestoresInput, _a2 ...request.Option) (*ec2.DescribeFastSnapshotRestoresOutput, 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 *ec2.DescribeFastSnapshotRestoresOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFastSnapshotRestoresInput, ...request.Option) *ec2.DescribeFastSnapshotRestoresOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFastSnapshotRestoresOutput)
		}
	}

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

	return r0, r1
}

// DescribeFleetHistory provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFleetHistory(_a0 *ec2.DescribeFleetHistoryInput) (*ec2.DescribeFleetHistoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeFleetHistoryOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeFleetHistoryInput) *ec2.DescribeFleetHistoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetHistoryOutput)
		}
	}

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

	return r0, r1
}

// DescribeFleetHistoryRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFleetHistoryRequest(_a0 *ec2.DescribeFleetHistoryInput) (*request.Request, *ec2.DescribeFleetHistoryOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeFleetHistoryOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeFleetHistoryInput) *ec2.DescribeFleetHistoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeFleetHistoryOutput)
		}
	}

	return r0, r1
}

// DescribeFleetHistoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeFleetHistoryWithContext(_a0 context.Context, _a1 *ec2.DescribeFleetHistoryInput, _a2 ...request.Option) (*ec2.DescribeFleetHistoryOutput, 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 *ec2.DescribeFleetHistoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetHistoryInput, ...request.Option) *ec2.DescribeFleetHistoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetHistoryOutput)
		}
	}

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

	return r0, r1
}

// DescribeFleetInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFleetInstances(_a0 *ec2.DescribeFleetInstancesInput) (*ec2.DescribeFleetInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeFleetInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeFleetInstancesInput) *ec2.DescribeFleetInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeFleetInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFleetInstancesRequest(_a0 *ec2.DescribeFleetInstancesInput) (*request.Request, *ec2.DescribeFleetInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeFleetInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeFleetInstancesInput) *ec2.DescribeFleetInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeFleetInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeFleetInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeFleetInstancesWithContext(_a0 context.Context, _a1 *ec2.DescribeFleetInstancesInput, _a2 ...request.Option) (*ec2.DescribeFleetInstancesOutput, 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 *ec2.DescribeFleetInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetInstancesInput, ...request.Option) *ec2.DescribeFleetInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeFleets provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFleets(_a0 *ec2.DescribeFleetsInput) (*ec2.DescribeFleetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeFleetsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeFleetsInput) *ec2.DescribeFleetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetsOutput)
		}
	}

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

	return r0, r1
}

// DescribeFleetsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeFleetsPages(_a0 *ec2.DescribeFleetsInput, _a1 func(*ec2.DescribeFleetsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeFleetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeFleetsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeFleetsInput, _a2 func(*ec2.DescribeFleetsOutput, 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, *ec2.DescribeFleetsInput, func(*ec2.DescribeFleetsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeFleetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFleetsRequest(_a0 *ec2.DescribeFleetsInput) (*request.Request, *ec2.DescribeFleetsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeFleetsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeFleetsInput) *ec2.DescribeFleetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeFleetsOutput)
		}
	}

	return r0, r1
}

// DescribeFleetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeFleetsWithContext(_a0 context.Context, _a1 *ec2.DescribeFleetsInput, _a2 ...request.Option) (*ec2.DescribeFleetsOutput, 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 *ec2.DescribeFleetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetsInput, ...request.Option) *ec2.DescribeFleetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetsOutput)
		}
	}

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

	return r0, r1
}

// DescribeFlowLogs provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFlowLogs(_a0 *ec2.DescribeFlowLogsInput) (*ec2.DescribeFlowLogsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeFlowLogsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeFlowLogsInput) *ec2.DescribeFlowLogsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFlowLogsOutput)
		}
	}

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

	return r0, r1
}

// DescribeFlowLogsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeFlowLogsPages(_a0 *ec2.DescribeFlowLogsInput, _a1 func(*ec2.DescribeFlowLogsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeFlowLogsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeFlowLogsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeFlowLogsInput, _a2 func(*ec2.DescribeFlowLogsOutput, 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, *ec2.DescribeFlowLogsInput, func(*ec2.DescribeFlowLogsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeFlowLogsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFlowLogsRequest(_a0 *ec2.DescribeFlowLogsInput) (*request.Request, *ec2.DescribeFlowLogsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeFlowLogsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeFlowLogsInput) *ec2.DescribeFlowLogsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeFlowLogsOutput)
		}
	}

	return r0, r1
}

// DescribeFlowLogsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeFlowLogsWithContext(_a0 context.Context, _a1 *ec2.DescribeFlowLogsInput, _a2 ...request.Option) (*ec2.DescribeFlowLogsOutput, 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 *ec2.DescribeFlowLogsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFlowLogsInput, ...request.Option) *ec2.DescribeFlowLogsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFlowLogsOutput)
		}
	}

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

	return r0, r1
}

// DescribeFpgaImageAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFpgaImageAttribute(_a0 *ec2.DescribeFpgaImageAttributeInput) (*ec2.DescribeFpgaImageAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeFpgaImageAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeFpgaImageAttributeInput) *ec2.DescribeFpgaImageAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFpgaImageAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeFpgaImageAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFpgaImageAttributeRequest(_a0 *ec2.DescribeFpgaImageAttributeInput) (*request.Request, *ec2.DescribeFpgaImageAttributeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeFpgaImageAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeFpgaImageAttributeInput) *ec2.DescribeFpgaImageAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeFpgaImageAttributeOutput)
		}
	}

	return r0, r1
}

// DescribeFpgaImageAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeFpgaImageAttributeWithContext(_a0 context.Context, _a1 *ec2.DescribeFpgaImageAttributeInput, _a2 ...request.Option) (*ec2.DescribeFpgaImageAttributeOutput, 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 *ec2.DescribeFpgaImageAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFpgaImageAttributeInput, ...request.Option) *ec2.DescribeFpgaImageAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFpgaImageAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeFpgaImages provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFpgaImages(_a0 *ec2.DescribeFpgaImagesInput) (*ec2.DescribeFpgaImagesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeFpgaImagesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeFpgaImagesInput) *ec2.DescribeFpgaImagesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFpgaImagesOutput)
		}
	}

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

	return r0, r1
}

// DescribeFpgaImagesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeFpgaImagesPages(_a0 *ec2.DescribeFpgaImagesInput, _a1 func(*ec2.DescribeFpgaImagesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeFpgaImagesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeFpgaImagesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeFpgaImagesInput, _a2 func(*ec2.DescribeFpgaImagesOutput, 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, *ec2.DescribeFpgaImagesInput, func(*ec2.DescribeFpgaImagesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeFpgaImagesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeFpgaImagesRequest(_a0 *ec2.DescribeFpgaImagesInput) (*request.Request, *ec2.DescribeFpgaImagesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeFpgaImagesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeFpgaImagesInput) *ec2.DescribeFpgaImagesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeFpgaImagesOutput)
		}
	}

	return r0, r1
}

// DescribeFpgaImagesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeFpgaImagesWithContext(_a0 context.Context, _a1 *ec2.DescribeFpgaImagesInput, _a2 ...request.Option) (*ec2.DescribeFpgaImagesOutput, 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 *ec2.DescribeFpgaImagesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFpgaImagesInput, ...request.Option) *ec2.DescribeFpgaImagesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFpgaImagesOutput)
		}
	}

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

	return r0, r1
}

// DescribeHostReservationOfferings provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeHostReservationOfferings(_a0 *ec2.DescribeHostReservationOfferingsInput) (*ec2.DescribeHostReservationOfferingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeHostReservationOfferingsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeHostReservationOfferingsInput) *ec2.DescribeHostReservationOfferingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostReservationOfferingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeHostReservationOfferingsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeHostReservationOfferingsPages(_a0 *ec2.DescribeHostReservationOfferingsInput, _a1 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeHostReservationOfferingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeHostReservationOfferingsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeHostReservationOfferingsInput, _a2 func(*ec2.DescribeHostReservationOfferingsOutput, 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, *ec2.DescribeHostReservationOfferingsInput, func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeHostReservationOfferingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeHostReservationOfferingsRequest(_a0 *ec2.DescribeHostReservationOfferingsInput) (*request.Request, *ec2.DescribeHostReservationOfferingsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeHostReservationOfferingsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeHostReservationOfferingsInput) *ec2.DescribeHostReservationOfferingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeHostReservationOfferingsOutput)
		}
	}

	return r0, r1
}

// DescribeHostReservationOfferingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeHostReservationOfferingsWithContext(_a0 context.Context, _a1 *ec2.DescribeHostReservationOfferingsInput, _a2 ...request.Option) (*ec2.DescribeHostReservationOfferingsOutput, 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 *ec2.DescribeHostReservationOfferingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostReservationOfferingsInput, ...request.Option) *ec2.DescribeHostReservationOfferingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostReservationOfferingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeHostReservations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeHostReservations(_a0 *ec2.DescribeHostReservationsInput) (*ec2.DescribeHostReservationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeHostReservationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeHostReservationsInput) *ec2.DescribeHostReservationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostReservationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeHostReservationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeHostReservationsPages(_a0 *ec2.DescribeHostReservationsInput, _a1 func(*ec2.DescribeHostReservationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeHostReservationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeHostReservationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeHostReservationsInput, _a2 func(*ec2.DescribeHostReservationsOutput, 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, *ec2.DescribeHostReservationsInput, func(*ec2.DescribeHostReservationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeHostReservationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeHostReservationsRequest(_a0 *ec2.DescribeHostReservationsInput) (*request.Request, *ec2.DescribeHostReservationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeHostReservationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeHostReservationsInput) *ec2.DescribeHostReservationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeHostReservationsOutput)
		}
	}

	return r0, r1
}

// DescribeHostReservationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeHostReservationsWithContext(_a0 context.Context, _a1 *ec2.DescribeHostReservationsInput, _a2 ...request.Option) (*ec2.DescribeHostReservationsOutput, 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 *ec2.DescribeHostReservationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostReservationsInput, ...request.Option) *ec2.DescribeHostReservationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostReservationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeHosts provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeHosts(_a0 *ec2.DescribeHostsInput) (*ec2.DescribeHostsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeHostsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeHostsInput) *ec2.DescribeHostsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostsOutput)
		}
	}

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

	return r0, r1
}

// DescribeHostsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeHostsPages(_a0 *ec2.DescribeHostsInput, _a1 func(*ec2.DescribeHostsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeHostsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeHostsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeHostsInput, _a2 func(*ec2.DescribeHostsOutput, 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, *ec2.DescribeHostsInput, func(*ec2.DescribeHostsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeHostsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeHostsRequest(_a0 *ec2.DescribeHostsInput) (*request.Request, *ec2.DescribeHostsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeHostsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeHostsInput) *ec2.DescribeHostsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeHostsOutput)
		}
	}

	return r0, r1
}

// DescribeHostsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeHostsWithContext(_a0 context.Context, _a1 *ec2.DescribeHostsInput, _a2 ...request.Option) (*ec2.DescribeHostsOutput, 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 *ec2.DescribeHostsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostsInput, ...request.Option) *ec2.DescribeHostsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostsOutput)
		}
	}

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

	return r0, r1
}

// DescribeIamInstanceProfileAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeIamInstanceProfileAssociations(_a0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeIamInstanceProfileAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeIamInstanceProfileAssociationsInput) *ec2.DescribeIamInstanceProfileAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIamInstanceProfileAssociationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeIamInstanceProfileAssociationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeIamInstanceProfileAssociationsPages(_a0 *ec2.DescribeIamInstanceProfileAssociationsInput, _a1 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeIamInstanceProfileAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeIamInstanceProfileAssociationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeIamInstanceProfileAssociationsInput, _a2 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, 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, *ec2.DescribeIamInstanceProfileAssociationsInput, func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeIamInstanceProfileAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeIamInstanceProfileAssociationsRequest(_a0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*request.Request, *ec2.DescribeIamInstanceProfileAssociationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeIamInstanceProfileAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeIamInstanceProfileAssociationsInput) *ec2.DescribeIamInstanceProfileAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeIamInstanceProfileAssociationsOutput)
		}
	}

	return r0, r1
}

// DescribeIamInstanceProfileAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeIamInstanceProfileAssociationsWithContext(_a0 context.Context, _a1 *ec2.DescribeIamInstanceProfileAssociationsInput, _a2 ...request.Option) (*ec2.DescribeIamInstanceProfileAssociationsOutput, 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 *ec2.DescribeIamInstanceProfileAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIamInstanceProfileAssociationsInput, ...request.Option) *ec2.DescribeIamInstanceProfileAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIamInstanceProfileAssociationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeIdFormat provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeIdFormat(_a0 *ec2.DescribeIdFormatInput) (*ec2.DescribeIdFormatOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeIdFormatOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeIdFormatInput) *ec2.DescribeIdFormatOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIdFormatOutput)
		}
	}

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

	return r0, r1
}

// DescribeIdFormatRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeIdFormatRequest(_a0 *ec2.DescribeIdFormatInput) (*request.Request, *ec2.DescribeIdFormatOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeIdFormatOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeIdFormatInput) *ec2.DescribeIdFormatOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeIdFormatOutput)
		}
	}

	return r0, r1
}

// DescribeIdFormatWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeIdFormatWithContext(_a0 context.Context, _a1 *ec2.DescribeIdFormatInput, _a2 ...request.Option) (*ec2.DescribeIdFormatOutput, 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 *ec2.DescribeIdFormatOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIdFormatInput, ...request.Option) *ec2.DescribeIdFormatOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIdFormatOutput)
		}
	}

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

	return r0, r1
}

// DescribeIdentityIdFormat provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeIdentityIdFormat(_a0 *ec2.DescribeIdentityIdFormatInput) (*ec2.DescribeIdentityIdFormatOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeIdentityIdFormatOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeIdentityIdFormatInput) *ec2.DescribeIdentityIdFormatOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIdentityIdFormatOutput)
		}
	}

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

	return r0, r1
}

// DescribeIdentityIdFormatRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeIdentityIdFormatRequest(_a0 *ec2.DescribeIdentityIdFormatInput) (*request.Request, *ec2.DescribeIdentityIdFormatOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeIdentityIdFormatOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeIdentityIdFormatInput) *ec2.DescribeIdentityIdFormatOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeIdentityIdFormatOutput)
		}
	}

	return r0, r1
}

// DescribeIdentityIdFormatWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeIdentityIdFormatWithContext(_a0 context.Context, _a1 *ec2.DescribeIdentityIdFormatInput, _a2 ...request.Option) (*ec2.DescribeIdentityIdFormatOutput, 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 *ec2.DescribeIdentityIdFormatOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIdentityIdFormatInput, ...request.Option) *ec2.DescribeIdentityIdFormatOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIdentityIdFormatOutput)
		}
	}

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

	return r0, r1
}

// DescribeImageAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeImageAttribute(_a0 *ec2.DescribeImageAttributeInput) (*ec2.DescribeImageAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeImageAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeImageAttributeInput) *ec2.DescribeImageAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImageAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeImageAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeImageAttributeRequest(_a0 *ec2.DescribeImageAttributeInput) (*request.Request, *ec2.DescribeImageAttributeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeImageAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeImageAttributeInput) *ec2.DescribeImageAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeImageAttributeOutput)
		}
	}

	return r0, r1
}

// DescribeImageAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeImageAttributeWithContext(_a0 context.Context, _a1 *ec2.DescribeImageAttributeInput, _a2 ...request.Option) (*ec2.DescribeImageAttributeOutput, 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 *ec2.DescribeImageAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageAttributeInput, ...request.Option) *ec2.DescribeImageAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImageAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeImages provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeImages(_a0 *ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeImagesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeImagesInput) *ec2.DescribeImagesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImagesOutput)
		}
	}

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

	return r0, r1
}

// DescribeImagesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeImagesRequest(_a0 *ec2.DescribeImagesInput) (*request.Request, *ec2.DescribeImagesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeImagesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeImagesInput) *ec2.DescribeImagesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeImagesOutput)
		}
	}

	return r0, r1
}

// DescribeImagesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeImagesWithContext(_a0 context.Context, _a1 *ec2.DescribeImagesInput, _a2 ...request.Option) (*ec2.DescribeImagesOutput, 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 *ec2.DescribeImagesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImagesInput, ...request.Option) *ec2.DescribeImagesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImagesOutput)
		}
	}

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

	return r0, r1
}

// DescribeImportImageTasks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeImportImageTasks(_a0 *ec2.DescribeImportImageTasksInput) (*ec2.DescribeImportImageTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeImportImageTasksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeImportImageTasksInput) *ec2.DescribeImportImageTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImportImageTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeImportImageTasksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeImportImageTasksPages(_a0 *ec2.DescribeImportImageTasksInput, _a1 func(*ec2.DescribeImportImageTasksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeImportImageTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeImportImageTasksPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeImportImageTasksInput, _a2 func(*ec2.DescribeImportImageTasksOutput, 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, *ec2.DescribeImportImageTasksInput, func(*ec2.DescribeImportImageTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeImportImageTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeImportImageTasksRequest(_a0 *ec2.DescribeImportImageTasksInput) (*request.Request, *ec2.DescribeImportImageTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeImportImageTasksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeImportImageTasksInput) *ec2.DescribeImportImageTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeImportImageTasksOutput)
		}
	}

	return r0, r1
}

// DescribeImportImageTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeImportImageTasksWithContext(_a0 context.Context, _a1 *ec2.DescribeImportImageTasksInput, _a2 ...request.Option) (*ec2.DescribeImportImageTasksOutput, 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 *ec2.DescribeImportImageTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImportImageTasksInput, ...request.Option) *ec2.DescribeImportImageTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImportImageTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeImportSnapshotTasks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeImportSnapshotTasks(_a0 *ec2.DescribeImportSnapshotTasksInput) (*ec2.DescribeImportSnapshotTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeImportSnapshotTasksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeImportSnapshotTasksInput) *ec2.DescribeImportSnapshotTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImportSnapshotTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeImportSnapshotTasksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeImportSnapshotTasksPages(_a0 *ec2.DescribeImportSnapshotTasksInput, _a1 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeImportSnapshotTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeImportSnapshotTasksPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeImportSnapshotTasksInput, _a2 func(*ec2.DescribeImportSnapshotTasksOutput, 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, *ec2.DescribeImportSnapshotTasksInput, func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeImportSnapshotTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeImportSnapshotTasksRequest(_a0 *ec2.DescribeImportSnapshotTasksInput) (*request.Request, *ec2.DescribeImportSnapshotTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeImportSnapshotTasksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeImportSnapshotTasksInput) *ec2.DescribeImportSnapshotTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeImportSnapshotTasksOutput)
		}
	}

	return r0, r1
}

// DescribeImportSnapshotTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeImportSnapshotTasksWithContext(_a0 context.Context, _a1 *ec2.DescribeImportSnapshotTasksInput, _a2 ...request.Option) (*ec2.DescribeImportSnapshotTasksOutput, 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 *ec2.DescribeImportSnapshotTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImportSnapshotTasksInput, ...request.Option) *ec2.DescribeImportSnapshotTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImportSnapshotTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceAttribute(_a0 *ec2.DescribeInstanceAttributeInput) (*ec2.DescribeInstanceAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeInstanceAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstanceAttributeInput) *ec2.DescribeInstanceAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceAttributeRequest(_a0 *ec2.DescribeInstanceAttributeInput) (*request.Request, *ec2.DescribeInstanceAttributeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeInstanceAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeInstanceAttributeInput) *ec2.DescribeInstanceAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeInstanceAttributeOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeInstanceAttributeWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceAttributeInput, _a2 ...request.Option) (*ec2.DescribeInstanceAttributeOutput, 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 *ec2.DescribeInstanceAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceAttributeInput, ...request.Option) *ec2.DescribeInstanceAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceCreditSpecifications provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceCreditSpecifications(_a0 *ec2.DescribeInstanceCreditSpecificationsInput) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeInstanceCreditSpecificationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstanceCreditSpecificationsInput) *ec2.DescribeInstanceCreditSpecificationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceCreditSpecificationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceCreditSpecificationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeInstanceCreditSpecificationsPages(_a0 *ec2.DescribeInstanceCreditSpecificationsInput, _a1 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeInstanceCreditSpecificationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeInstanceCreditSpecificationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceCreditSpecificationsInput, _a2 func(*ec2.DescribeInstanceCreditSpecificationsOutput, 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, *ec2.DescribeInstanceCreditSpecificationsInput, func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstanceCreditSpecificationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceCreditSpecificationsRequest(_a0 *ec2.DescribeInstanceCreditSpecificationsInput) (*request.Request, *ec2.DescribeInstanceCreditSpecificationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeInstanceCreditSpecificationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeInstanceCreditSpecificationsInput) *ec2.DescribeInstanceCreditSpecificationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeInstanceCreditSpecificationsOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceCreditSpecificationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeInstanceCreditSpecificationsWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceCreditSpecificationsInput, _a2 ...request.Option) (*ec2.DescribeInstanceCreditSpecificationsOutput, 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 *ec2.DescribeInstanceCreditSpecificationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceCreditSpecificationsInput, ...request.Option) *ec2.DescribeInstanceCreditSpecificationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceCreditSpecificationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceEventNotificationAttributes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceEventNotificationAttributes(_a0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstanceEventNotificationAttributesInput) *ec2.DescribeInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceEventNotificationAttributesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceEventNotificationAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceEventNotificationAttributesRequest(_a0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DescribeInstanceEventNotificationAttributesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeInstanceEventNotificationAttributesInput) *ec2.DescribeInstanceEventNotificationAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeInstanceEventNotificationAttributesOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceEventNotificationAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeInstanceEventNotificationAttributesWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceEventNotificationAttributesInput, _a2 ...request.Option) (*ec2.DescribeInstanceEventNotificationAttributesOutput, 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 *ec2.DescribeInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceEventNotificationAttributesInput, ...request.Option) *ec2.DescribeInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceEventNotificationAttributesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceStatus provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceStatus(_a0 *ec2.DescribeInstanceStatusInput) (*ec2.DescribeInstanceStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeInstanceStatusOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstanceStatusInput) *ec2.DescribeInstanceStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceStatusOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceStatusPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeInstanceStatusPages(_a0 *ec2.DescribeInstanceStatusInput, _a1 func(*ec2.DescribeInstanceStatusOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeInstanceStatusPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeInstanceStatusPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceStatusInput, _a2 func(*ec2.DescribeInstanceStatusOutput, 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, *ec2.DescribeInstanceStatusInput, func(*ec2.DescribeInstanceStatusOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstanceStatusRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceStatusRequest(_a0 *ec2.DescribeInstanceStatusInput) (*request.Request, *ec2.DescribeInstanceStatusOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeInstanceStatusOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeInstanceStatusInput) *ec2.DescribeInstanceStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeInstanceStatusOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeInstanceStatusWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceStatusInput, _a2 ...request.Option) (*ec2.DescribeInstanceStatusOutput, 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 *ec2.DescribeInstanceStatusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceStatusInput, ...request.Option) *ec2.DescribeInstanceStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceStatusOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceTypeOfferings provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceTypeOfferings(_a0 *ec2.DescribeInstanceTypeOfferingsInput) (*ec2.DescribeInstanceTypeOfferingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeInstanceTypeOfferingsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstanceTypeOfferingsInput) *ec2.DescribeInstanceTypeOfferingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceTypeOfferingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceTypeOfferingsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeInstanceTypeOfferingsPages(_a0 *ec2.DescribeInstanceTypeOfferingsInput, _a1 func(*ec2.DescribeInstanceTypeOfferingsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeInstanceTypeOfferingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeInstanceTypeOfferingsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceTypeOfferingsInput, _a2 func(*ec2.DescribeInstanceTypeOfferingsOutput, 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, *ec2.DescribeInstanceTypeOfferingsInput, func(*ec2.DescribeInstanceTypeOfferingsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstanceTypeOfferingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceTypeOfferingsRequest(_a0 *ec2.DescribeInstanceTypeOfferingsInput) (*request.Request, *ec2.DescribeInstanceTypeOfferingsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeInstanceTypeOfferingsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeInstanceTypeOfferingsInput) *ec2.DescribeInstanceTypeOfferingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeInstanceTypeOfferingsOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceTypeOfferingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeInstanceTypeOfferingsWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceTypeOfferingsInput, _a2 ...request.Option) (*ec2.DescribeInstanceTypeOfferingsOutput, 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 *ec2.DescribeInstanceTypeOfferingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceTypeOfferingsInput, ...request.Option) *ec2.DescribeInstanceTypeOfferingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceTypeOfferingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceTypes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceTypes(_a0 *ec2.DescribeInstanceTypesInput) (*ec2.DescribeInstanceTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeInstanceTypesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstanceTypesInput) *ec2.DescribeInstanceTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceTypesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeInstanceTypesPages(_a0 *ec2.DescribeInstanceTypesInput, _a1 func(*ec2.DescribeInstanceTypesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeInstanceTypesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeInstanceTypesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceTypesInput, _a2 func(*ec2.DescribeInstanceTypesOutput, 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, *ec2.DescribeInstanceTypesInput, func(*ec2.DescribeInstanceTypesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstanceTypesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstanceTypesRequest(_a0 *ec2.DescribeInstanceTypesInput) (*request.Request, *ec2.DescribeInstanceTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeInstanceTypesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeInstanceTypesInput) *ec2.DescribeInstanceTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeInstanceTypesOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceTypesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeInstanceTypesWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceTypesInput, _a2 ...request.Option) (*ec2.DescribeInstanceTypesOutput, 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 *ec2.DescribeInstanceTypesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceTypesInput, ...request.Option) *ec2.DescribeInstanceTypesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstances(_a0 *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstancesInput) *ec2.DescribeInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeInstancesPages(_a0 *ec2.DescribeInstancesInput, _a1 func(*ec2.DescribeInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeInstancesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeInstancesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeInstancesInput, _a2 func(*ec2.DescribeInstancesOutput, 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, *ec2.DescribeInstancesInput, func(*ec2.DescribeInstancesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInstancesRequest(_a0 *ec2.DescribeInstancesInput) (*request.Request, *ec2.DescribeInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeInstancesInput) *ec2.DescribeInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeInstancesWithContext(_a0 context.Context, _a1 *ec2.DescribeInstancesInput, _a2 ...request.Option) (*ec2.DescribeInstancesOutput, 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 *ec2.DescribeInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstancesInput, ...request.Option) *ec2.DescribeInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInternetGateways provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInternetGateways(_a0 *ec2.DescribeInternetGatewaysInput) (*ec2.DescribeInternetGatewaysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeInternetGatewaysOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInternetGatewaysInput) *ec2.DescribeInternetGatewaysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInternetGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeInternetGatewaysPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeInternetGatewaysPages(_a0 *ec2.DescribeInternetGatewaysInput, _a1 func(*ec2.DescribeInternetGatewaysOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeInternetGatewaysPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeInternetGatewaysPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeInternetGatewaysInput, _a2 func(*ec2.DescribeInternetGatewaysOutput, 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, *ec2.DescribeInternetGatewaysInput, func(*ec2.DescribeInternetGatewaysOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInternetGatewaysRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeInternetGatewaysRequest(_a0 *ec2.DescribeInternetGatewaysInput) (*request.Request, *ec2.DescribeInternetGatewaysOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeInternetGatewaysOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeInternetGatewaysInput) *ec2.DescribeInternetGatewaysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeInternetGatewaysOutput)
		}
	}

	return r0, r1
}

// DescribeInternetGatewaysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeInternetGatewaysWithContext(_a0 context.Context, _a1 *ec2.DescribeInternetGatewaysInput, _a2 ...request.Option) (*ec2.DescribeInternetGatewaysOutput, 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 *ec2.DescribeInternetGatewaysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInternetGatewaysInput, ...request.Option) *ec2.DescribeInternetGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInternetGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeIpv6Pools provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeIpv6Pools(_a0 *ec2.DescribeIpv6PoolsInput) (*ec2.DescribeIpv6PoolsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeIpv6PoolsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeIpv6PoolsInput) *ec2.DescribeIpv6PoolsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpv6PoolsOutput)
		}
	}

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

	return r0, r1
}

// DescribeIpv6PoolsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeIpv6PoolsPages(_a0 *ec2.DescribeIpv6PoolsInput, _a1 func(*ec2.DescribeIpv6PoolsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeIpv6PoolsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeIpv6PoolsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeIpv6PoolsInput, _a2 func(*ec2.DescribeIpv6PoolsOutput, 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, *ec2.DescribeIpv6PoolsInput, func(*ec2.DescribeIpv6PoolsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeIpv6PoolsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeIpv6PoolsRequest(_a0 *ec2.DescribeIpv6PoolsInput) (*request.Request, *ec2.DescribeIpv6PoolsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeIpv6PoolsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeIpv6PoolsInput) *ec2.DescribeIpv6PoolsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeIpv6PoolsOutput)
		}
	}

	return r0, r1
}

// DescribeIpv6PoolsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeIpv6PoolsWithContext(_a0 context.Context, _a1 *ec2.DescribeIpv6PoolsInput, _a2 ...request.Option) (*ec2.DescribeIpv6PoolsOutput, 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 *ec2.DescribeIpv6PoolsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpv6PoolsInput, ...request.Option) *ec2.DescribeIpv6PoolsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpv6PoolsOutput)
		}
	}

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

	return r0, r1
}

// DescribeKeyPairs provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeKeyPairs(_a0 *ec2.DescribeKeyPairsInput) (*ec2.DescribeKeyPairsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeKeyPairsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeKeyPairsInput) *ec2.DescribeKeyPairsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeKeyPairsOutput)
		}
	}

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

	return r0, r1
}

// DescribeKeyPairsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeKeyPairsRequest(_a0 *ec2.DescribeKeyPairsInput) (*request.Request, *ec2.DescribeKeyPairsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeKeyPairsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeKeyPairsInput) *ec2.DescribeKeyPairsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeKeyPairsOutput)
		}
	}

	return r0, r1
}

// DescribeKeyPairsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeKeyPairsWithContext(_a0 context.Context, _a1 *ec2.DescribeKeyPairsInput, _a2 ...request.Option) (*ec2.DescribeKeyPairsOutput, 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 *ec2.DescribeKeyPairsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeKeyPairsInput, ...request.Option) *ec2.DescribeKeyPairsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeKeyPairsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLaunchTemplateVersions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLaunchTemplateVersions(_a0 *ec2.DescribeLaunchTemplateVersionsInput) (*ec2.DescribeLaunchTemplateVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeLaunchTemplateVersionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeLaunchTemplateVersionsInput) *ec2.DescribeLaunchTemplateVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLaunchTemplateVersionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLaunchTemplateVersionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeLaunchTemplateVersionsPages(_a0 *ec2.DescribeLaunchTemplateVersionsInput, _a1 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLaunchTemplateVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeLaunchTemplateVersionsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeLaunchTemplateVersionsInput, _a2 func(*ec2.DescribeLaunchTemplateVersionsOutput, 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, *ec2.DescribeLaunchTemplateVersionsInput, func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLaunchTemplateVersionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLaunchTemplateVersionsRequest(_a0 *ec2.DescribeLaunchTemplateVersionsInput) (*request.Request, *ec2.DescribeLaunchTemplateVersionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeLaunchTemplateVersionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeLaunchTemplateVersionsInput) *ec2.DescribeLaunchTemplateVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeLaunchTemplateVersionsOutput)
		}
	}

	return r0, r1
}

// DescribeLaunchTemplateVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeLaunchTemplateVersionsWithContext(_a0 context.Context, _a1 *ec2.DescribeLaunchTemplateVersionsInput, _a2 ...request.Option) (*ec2.DescribeLaunchTemplateVersionsOutput, 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 *ec2.DescribeLaunchTemplateVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLaunchTemplateVersionsInput, ...request.Option) *ec2.DescribeLaunchTemplateVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLaunchTemplateVersionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLaunchTemplates provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLaunchTemplates(_a0 *ec2.DescribeLaunchTemplatesInput) (*ec2.DescribeLaunchTemplatesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeLaunchTemplatesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeLaunchTemplatesInput) *ec2.DescribeLaunchTemplatesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLaunchTemplatesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLaunchTemplatesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeLaunchTemplatesPages(_a0 *ec2.DescribeLaunchTemplatesInput, _a1 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLaunchTemplatesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeLaunchTemplatesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeLaunchTemplatesInput, _a2 func(*ec2.DescribeLaunchTemplatesOutput, 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, *ec2.DescribeLaunchTemplatesInput, func(*ec2.DescribeLaunchTemplatesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLaunchTemplatesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLaunchTemplatesRequest(_a0 *ec2.DescribeLaunchTemplatesInput) (*request.Request, *ec2.DescribeLaunchTemplatesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeLaunchTemplatesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeLaunchTemplatesInput) *ec2.DescribeLaunchTemplatesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeLaunchTemplatesOutput)
		}
	}

	return r0, r1
}

// DescribeLaunchTemplatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeLaunchTemplatesWithContext(_a0 context.Context, _a1 *ec2.DescribeLaunchTemplatesInput, _a2 ...request.Option) (*ec2.DescribeLaunchTemplatesOutput, 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 *ec2.DescribeLaunchTemplatesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLaunchTemplatesInput, ...request.Option) *ec2.DescribeLaunchTemplatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLaunchTemplatesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(_a0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(_a0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, _a1 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, _a2 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, 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, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(_a0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
		}
	}

	return r0, r1
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, _a2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, 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 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, ...request.Option) *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayRouteTableVpcAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVpcAssociations(_a0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayRouteTableVpcAssociationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVpcAssociationsPages(_a0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, _a1 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, _a2 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, 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, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLocalGatewayRouteTableVpcAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVpcAssociationsRequest(_a0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
		}
	}

	return r0, r1
}

// DescribeLocalGatewayRouteTableVpcAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, _a2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, 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 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, ...request.Option) *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayRouteTables provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTables(_a0 *ec2.DescribeLocalGatewayRouteTablesInput) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeLocalGatewayRouteTablesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeLocalGatewayRouteTablesInput) *ec2.DescribeLocalGatewayRouteTablesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTablesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayRouteTablesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTablesPages(_a0 *ec2.DescribeLocalGatewayRouteTablesInput, _a1 func(*ec2.DescribeLocalGatewayRouteTablesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLocalGatewayRouteTablesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTablesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayRouteTablesInput, _a2 func(*ec2.DescribeLocalGatewayRouteTablesOutput, 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, *ec2.DescribeLocalGatewayRouteTablesInput, func(*ec2.DescribeLocalGatewayRouteTablesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLocalGatewayRouteTablesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTablesRequest(_a0 *ec2.DescribeLocalGatewayRouteTablesInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTablesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeLocalGatewayRouteTablesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeLocalGatewayRouteTablesInput) *ec2.DescribeLocalGatewayRouteTablesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeLocalGatewayRouteTablesOutput)
		}
	}

	return r0, r1
}

// DescribeLocalGatewayRouteTablesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeLocalGatewayRouteTablesWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayRouteTablesInput, _a2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTablesOutput, 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 *ec2.DescribeLocalGatewayRouteTablesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTablesInput, ...request.Option) *ec2.DescribeLocalGatewayRouteTablesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTablesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayVirtualInterfaceGroups provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfaceGroups(_a0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayVirtualInterfaceGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfaceGroupsPages(_a0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, _a1 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, _a2 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, 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, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLocalGatewayVirtualInterfaceGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfaceGroupsRequest(_a0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeLocalGatewayVirtualInterfaceGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, _a2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, 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 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, ...request.Option) *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayVirtualInterfaces provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfaces(_a0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeLocalGatewayVirtualInterfacesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeLocalGatewayVirtualInterfacesInput) *ec2.DescribeLocalGatewayVirtualInterfacesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewayVirtualInterfacesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfacesPages(_a0 *ec2.DescribeLocalGatewayVirtualInterfacesInput, _a1 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLocalGatewayVirtualInterfacesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfacesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, _a2 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, 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, *ec2.DescribeLocalGatewayVirtualInterfacesInput, func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLocalGatewayVirtualInterfacesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfacesRequest(_a0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfacesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeLocalGatewayVirtualInterfacesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeLocalGatewayVirtualInterfacesInput) *ec2.DescribeLocalGatewayVirtualInterfacesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
		}
	}

	return r0, r1
}

// DescribeLocalGatewayVirtualInterfacesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeLocalGatewayVirtualInterfacesWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, _a2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, 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 *ec2.DescribeLocalGatewayVirtualInterfacesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfacesInput, ...request.Option) *ec2.DescribeLocalGatewayVirtualInterfacesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGateways provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGateways(_a0 *ec2.DescribeLocalGatewaysInput) (*ec2.DescribeLocalGatewaysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeLocalGatewaysOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeLocalGatewaysInput) *ec2.DescribeLocalGatewaysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeLocalGatewaysPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeLocalGatewaysPages(_a0 *ec2.DescribeLocalGatewaysInput, _a1 func(*ec2.DescribeLocalGatewaysOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLocalGatewaysPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeLocalGatewaysPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewaysInput, _a2 func(*ec2.DescribeLocalGatewaysOutput, 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, *ec2.DescribeLocalGatewaysInput, func(*ec2.DescribeLocalGatewaysOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLocalGatewaysRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeLocalGatewaysRequest(_a0 *ec2.DescribeLocalGatewaysInput) (*request.Request, *ec2.DescribeLocalGatewaysOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeLocalGatewaysOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeLocalGatewaysInput) *ec2.DescribeLocalGatewaysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeLocalGatewaysOutput)
		}
	}

	return r0, r1
}

// DescribeLocalGatewaysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeLocalGatewaysWithContext(_a0 context.Context, _a1 *ec2.DescribeLocalGatewaysInput, _a2 ...request.Option) (*ec2.DescribeLocalGatewaysOutput, 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 *ec2.DescribeLocalGatewaysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewaysInput, ...request.Option) *ec2.DescribeLocalGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeManagedPrefixLists provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeManagedPrefixLists(_a0 *ec2.DescribeManagedPrefixListsInput) (*ec2.DescribeManagedPrefixListsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeManagedPrefixListsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeManagedPrefixListsInput) *ec2.DescribeManagedPrefixListsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeManagedPrefixListsOutput)
		}
	}

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

	return r0, r1
}

// DescribeManagedPrefixListsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeManagedPrefixListsPages(_a0 *ec2.DescribeManagedPrefixListsInput, _a1 func(*ec2.DescribeManagedPrefixListsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeManagedPrefixListsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeManagedPrefixListsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeManagedPrefixListsInput, _a2 func(*ec2.DescribeManagedPrefixListsOutput, 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, *ec2.DescribeManagedPrefixListsInput, func(*ec2.DescribeManagedPrefixListsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeManagedPrefixListsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeManagedPrefixListsRequest(_a0 *ec2.DescribeManagedPrefixListsInput) (*request.Request, *ec2.DescribeManagedPrefixListsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeManagedPrefixListsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeManagedPrefixListsInput) *ec2.DescribeManagedPrefixListsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeManagedPrefixListsOutput)
		}
	}

	return r0, r1
}

// DescribeManagedPrefixListsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeManagedPrefixListsWithContext(_a0 context.Context, _a1 *ec2.DescribeManagedPrefixListsInput, _a2 ...request.Option) (*ec2.DescribeManagedPrefixListsOutput, 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 *ec2.DescribeManagedPrefixListsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeManagedPrefixListsInput, ...request.Option) *ec2.DescribeManagedPrefixListsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeManagedPrefixListsOutput)
		}
	}

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

	return r0, r1
}

// DescribeMovingAddresses provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeMovingAddresses(_a0 *ec2.DescribeMovingAddressesInput) (*ec2.DescribeMovingAddressesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeMovingAddressesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeMovingAddressesInput) *ec2.DescribeMovingAddressesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeMovingAddressesOutput)
		}
	}

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

	return r0, r1
}

// DescribeMovingAddressesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeMovingAddressesPages(_a0 *ec2.DescribeMovingAddressesInput, _a1 func(*ec2.DescribeMovingAddressesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeMovingAddressesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeMovingAddressesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeMovingAddressesInput, _a2 func(*ec2.DescribeMovingAddressesOutput, 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, *ec2.DescribeMovingAddressesInput, func(*ec2.DescribeMovingAddressesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeMovingAddressesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeMovingAddressesRequest(_a0 *ec2.DescribeMovingAddressesInput) (*request.Request, *ec2.DescribeMovingAddressesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeMovingAddressesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeMovingAddressesInput) *ec2.DescribeMovingAddressesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeMovingAddressesOutput)
		}
	}

	return r0, r1
}

// DescribeMovingAddressesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeMovingAddressesWithContext(_a0 context.Context, _a1 *ec2.DescribeMovingAddressesInput, _a2 ...request.Option) (*ec2.DescribeMovingAddressesOutput, 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 *ec2.DescribeMovingAddressesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeMovingAddressesInput, ...request.Option) *ec2.DescribeMovingAddressesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeMovingAddressesOutput)
		}
	}

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

	return r0, r1
}

// DescribeNatGateways provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNatGateways(_a0 *ec2.DescribeNatGatewaysInput) (*ec2.DescribeNatGatewaysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeNatGatewaysOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNatGatewaysInput) *ec2.DescribeNatGatewaysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNatGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeNatGatewaysPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeNatGatewaysPages(_a0 *ec2.DescribeNatGatewaysInput, _a1 func(*ec2.DescribeNatGatewaysOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeNatGatewaysPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeNatGatewaysPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeNatGatewaysInput, _a2 func(*ec2.DescribeNatGatewaysOutput, 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, *ec2.DescribeNatGatewaysInput, func(*ec2.DescribeNatGatewaysOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeNatGatewaysRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNatGatewaysRequest(_a0 *ec2.DescribeNatGatewaysInput) (*request.Request, *ec2.DescribeNatGatewaysOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeNatGatewaysOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeNatGatewaysInput) *ec2.DescribeNatGatewaysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeNatGatewaysOutput)
		}
	}

	return r0, r1
}

// DescribeNatGatewaysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeNatGatewaysWithContext(_a0 context.Context, _a1 *ec2.DescribeNatGatewaysInput, _a2 ...request.Option) (*ec2.DescribeNatGatewaysOutput, 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 *ec2.DescribeNatGatewaysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNatGatewaysInput, ...request.Option) *ec2.DescribeNatGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNatGatewaysOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkAcls provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkAcls(_a0 *ec2.DescribeNetworkAclsInput) (*ec2.DescribeNetworkAclsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeNetworkAclsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNetworkAclsInput) *ec2.DescribeNetworkAclsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkAclsOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkAclsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeNetworkAclsPages(_a0 *ec2.DescribeNetworkAclsInput, _a1 func(*ec2.DescribeNetworkAclsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeNetworkAclsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeNetworkAclsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkAclsInput, _a2 func(*ec2.DescribeNetworkAclsOutput, 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, *ec2.DescribeNetworkAclsInput, func(*ec2.DescribeNetworkAclsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeNetworkAclsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkAclsRequest(_a0 *ec2.DescribeNetworkAclsInput) (*request.Request, *ec2.DescribeNetworkAclsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeNetworkAclsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeNetworkAclsInput) *ec2.DescribeNetworkAclsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeNetworkAclsOutput)
		}
	}

	return r0, r1
}

// DescribeNetworkAclsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeNetworkAclsWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkAclsInput, _a2 ...request.Option) (*ec2.DescribeNetworkAclsOutput, 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 *ec2.DescribeNetworkAclsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkAclsInput, ...request.Option) *ec2.DescribeNetworkAclsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkAclsOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInsightsAnalyses provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInsightsAnalyses(_a0 *ec2.DescribeNetworkInsightsAnalysesInput) (*ec2.DescribeNetworkInsightsAnalysesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeNetworkInsightsAnalysesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNetworkInsightsAnalysesInput) *ec2.DescribeNetworkInsightsAnalysesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInsightsAnalysesOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInsightsAnalysesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeNetworkInsightsAnalysesPages(_a0 *ec2.DescribeNetworkInsightsAnalysesInput, _a1 func(*ec2.DescribeNetworkInsightsAnalysesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeNetworkInsightsAnalysesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeNetworkInsightsAnalysesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInsightsAnalysesInput, _a2 func(*ec2.DescribeNetworkInsightsAnalysesOutput, 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, *ec2.DescribeNetworkInsightsAnalysesInput, func(*ec2.DescribeNetworkInsightsAnalysesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeNetworkInsightsAnalysesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInsightsAnalysesRequest(_a0 *ec2.DescribeNetworkInsightsAnalysesInput) (*request.Request, *ec2.DescribeNetworkInsightsAnalysesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeNetworkInsightsAnalysesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeNetworkInsightsAnalysesInput) *ec2.DescribeNetworkInsightsAnalysesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeNetworkInsightsAnalysesOutput)
		}
	}

	return r0, r1
}

// DescribeNetworkInsightsAnalysesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeNetworkInsightsAnalysesWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInsightsAnalysesInput, _a2 ...request.Option) (*ec2.DescribeNetworkInsightsAnalysesOutput, 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 *ec2.DescribeNetworkInsightsAnalysesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsAnalysesInput, ...request.Option) *ec2.DescribeNetworkInsightsAnalysesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInsightsAnalysesOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInsightsPaths provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInsightsPaths(_a0 *ec2.DescribeNetworkInsightsPathsInput) (*ec2.DescribeNetworkInsightsPathsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeNetworkInsightsPathsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNetworkInsightsPathsInput) *ec2.DescribeNetworkInsightsPathsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInsightsPathsOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInsightsPathsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeNetworkInsightsPathsPages(_a0 *ec2.DescribeNetworkInsightsPathsInput, _a1 func(*ec2.DescribeNetworkInsightsPathsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeNetworkInsightsPathsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeNetworkInsightsPathsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInsightsPathsInput, _a2 func(*ec2.DescribeNetworkInsightsPathsOutput, 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, *ec2.DescribeNetworkInsightsPathsInput, func(*ec2.DescribeNetworkInsightsPathsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeNetworkInsightsPathsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInsightsPathsRequest(_a0 *ec2.DescribeNetworkInsightsPathsInput) (*request.Request, *ec2.DescribeNetworkInsightsPathsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeNetworkInsightsPathsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeNetworkInsightsPathsInput) *ec2.DescribeNetworkInsightsPathsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeNetworkInsightsPathsOutput)
		}
	}

	return r0, r1
}

// DescribeNetworkInsightsPathsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeNetworkInsightsPathsWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInsightsPathsInput, _a2 ...request.Option) (*ec2.DescribeNetworkInsightsPathsOutput, 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 *ec2.DescribeNetworkInsightsPathsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsPathsInput, ...request.Option) *ec2.DescribeNetworkInsightsPathsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInsightsPathsOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInterfaceAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInterfaceAttribute(_a0 *ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNetworkInterfaceAttributeInput) *ec2.DescribeNetworkInterfaceAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfaceAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInterfaceAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInterfaceAttributeRequest(_a0 *ec2.DescribeNetworkInterfaceAttributeInput) (*request.Request, *ec2.DescribeNetworkInterfaceAttributeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeNetworkInterfaceAttributeInput) *ec2.DescribeNetworkInterfaceAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeNetworkInterfaceAttributeOutput)
		}
	}

	return r0, r1
}

// DescribeNetworkInterfaceAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeNetworkInterfaceAttributeWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInterfaceAttributeInput, _a2 ...request.Option) (*ec2.DescribeNetworkInterfaceAttributeOutput, 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 *ec2.DescribeNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfaceAttributeInput, ...request.Option) *ec2.DescribeNetworkInterfaceAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfaceAttributeOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInterfacePermissions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInterfacePermissions(_a0 *ec2.DescribeNetworkInterfacePermissionsInput) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeNetworkInterfacePermissionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNetworkInterfacePermissionsInput) *ec2.DescribeNetworkInterfacePermissionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfacePermissionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInterfacePermissionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeNetworkInterfacePermissionsPages(_a0 *ec2.DescribeNetworkInterfacePermissionsInput, _a1 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeNetworkInterfacePermissionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeNetworkInterfacePermissionsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInterfacePermissionsInput, _a2 func(*ec2.DescribeNetworkInterfacePermissionsOutput, 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, *ec2.DescribeNetworkInterfacePermissionsInput, func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeNetworkInterfacePermissionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInterfacePermissionsRequest(_a0 *ec2.DescribeNetworkInterfacePermissionsInput) (*request.Request, *ec2.DescribeNetworkInterfacePermissionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeNetworkInterfacePermissionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeNetworkInterfacePermissionsInput) *ec2.DescribeNetworkInterfacePermissionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeNetworkInterfacePermissionsOutput)
		}
	}

	return r0, r1
}

// DescribeNetworkInterfacePermissionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeNetworkInterfacePermissionsWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInterfacePermissionsInput, _a2 ...request.Option) (*ec2.DescribeNetworkInterfacePermissionsOutput, 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 *ec2.DescribeNetworkInterfacePermissionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfacePermissionsInput, ...request.Option) *ec2.DescribeNetworkInterfacePermissionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfacePermissionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInterfaces provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInterfaces(_a0 *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeNetworkInterfacesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNetworkInterfacesInput) *ec2.DescribeNetworkInterfacesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfacesOutput)
		}
	}

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

	return r0, r1
}

// DescribeNetworkInterfacesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeNetworkInterfacesPages(_a0 *ec2.DescribeNetworkInterfacesInput, _a1 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeNetworkInterfacesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeNetworkInterfacesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInterfacesInput, _a2 func(*ec2.DescribeNetworkInterfacesOutput, 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, *ec2.DescribeNetworkInterfacesInput, func(*ec2.DescribeNetworkInterfacesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeNetworkInterfacesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeNetworkInterfacesRequest(_a0 *ec2.DescribeNetworkInterfacesInput) (*request.Request, *ec2.DescribeNetworkInterfacesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeNetworkInterfacesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeNetworkInterfacesInput) *ec2.DescribeNetworkInterfacesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeNetworkInterfacesOutput)
		}
	}

	return r0, r1
}

// DescribeNetworkInterfacesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeNetworkInterfacesWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInterfacesInput, _a2 ...request.Option) (*ec2.DescribeNetworkInterfacesOutput, 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 *ec2.DescribeNetworkInterfacesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfacesInput, ...request.Option) *ec2.DescribeNetworkInterfacesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfacesOutput)
		}
	}

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

	return r0, r1
}

// DescribePlacementGroups provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribePlacementGroups(_a0 *ec2.DescribePlacementGroupsInput) (*ec2.DescribePlacementGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribePlacementGroupsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribePlacementGroupsInput) *ec2.DescribePlacementGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePlacementGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribePlacementGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribePlacementGroupsRequest(_a0 *ec2.DescribePlacementGroupsInput) (*request.Request, *ec2.DescribePlacementGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribePlacementGroupsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribePlacementGroupsInput) *ec2.DescribePlacementGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribePlacementGroupsOutput)
		}
	}

	return r0, r1
}

// DescribePlacementGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribePlacementGroupsWithContext(_a0 context.Context, _a1 *ec2.DescribePlacementGroupsInput, _a2 ...request.Option) (*ec2.DescribePlacementGroupsOutput, 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 *ec2.DescribePlacementGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePlacementGroupsInput, ...request.Option) *ec2.DescribePlacementGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePlacementGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribePrefixLists provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribePrefixLists(_a0 *ec2.DescribePrefixListsInput) (*ec2.DescribePrefixListsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribePrefixListsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribePrefixListsInput) *ec2.DescribePrefixListsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePrefixListsOutput)
		}
	}

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

	return r0, r1
}

// DescribePrefixListsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribePrefixListsPages(_a0 *ec2.DescribePrefixListsInput, _a1 func(*ec2.DescribePrefixListsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribePrefixListsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribePrefixListsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribePrefixListsInput, _a2 func(*ec2.DescribePrefixListsOutput, 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, *ec2.DescribePrefixListsInput, func(*ec2.DescribePrefixListsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribePrefixListsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribePrefixListsRequest(_a0 *ec2.DescribePrefixListsInput) (*request.Request, *ec2.DescribePrefixListsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribePrefixListsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribePrefixListsInput) *ec2.DescribePrefixListsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribePrefixListsOutput)
		}
	}

	return r0, r1
}

// DescribePrefixListsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribePrefixListsWithContext(_a0 context.Context, _a1 *ec2.DescribePrefixListsInput, _a2 ...request.Option) (*ec2.DescribePrefixListsOutput, 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 *ec2.DescribePrefixListsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePrefixListsInput, ...request.Option) *ec2.DescribePrefixListsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePrefixListsOutput)
		}
	}

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

	return r0, r1
}

// DescribePrincipalIdFormat provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribePrincipalIdFormat(_a0 *ec2.DescribePrincipalIdFormatInput) (*ec2.DescribePrincipalIdFormatOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribePrincipalIdFormatOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribePrincipalIdFormatInput) *ec2.DescribePrincipalIdFormatOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePrincipalIdFormatOutput)
		}
	}

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

	return r0, r1
}

// DescribePrincipalIdFormatPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribePrincipalIdFormatPages(_a0 *ec2.DescribePrincipalIdFormatInput, _a1 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribePrincipalIdFormatPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribePrincipalIdFormatPagesWithContext(_a0 context.Context, _a1 *ec2.DescribePrincipalIdFormatInput, _a2 func(*ec2.DescribePrincipalIdFormatOutput, 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, *ec2.DescribePrincipalIdFormatInput, func(*ec2.DescribePrincipalIdFormatOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribePrincipalIdFormatRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribePrincipalIdFormatRequest(_a0 *ec2.DescribePrincipalIdFormatInput) (*request.Request, *ec2.DescribePrincipalIdFormatOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribePrincipalIdFormatOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribePrincipalIdFormatInput) *ec2.DescribePrincipalIdFormatOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribePrincipalIdFormatOutput)
		}
	}

	return r0, r1
}

// DescribePrincipalIdFormatWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribePrincipalIdFormatWithContext(_a0 context.Context, _a1 *ec2.DescribePrincipalIdFormatInput, _a2 ...request.Option) (*ec2.DescribePrincipalIdFormatOutput, 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 *ec2.DescribePrincipalIdFormatOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePrincipalIdFormatInput, ...request.Option) *ec2.DescribePrincipalIdFormatOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePrincipalIdFormatOutput)
		}
	}

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

	return r0, r1
}

// DescribePublicIpv4Pools provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribePublicIpv4Pools(_a0 *ec2.DescribePublicIpv4PoolsInput) (*ec2.DescribePublicIpv4PoolsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribePublicIpv4PoolsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribePublicIpv4PoolsInput) *ec2.DescribePublicIpv4PoolsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePublicIpv4PoolsOutput)
		}
	}

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

	return r0, r1
}

// DescribePublicIpv4PoolsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribePublicIpv4PoolsPages(_a0 *ec2.DescribePublicIpv4PoolsInput, _a1 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribePublicIpv4PoolsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribePublicIpv4PoolsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribePublicIpv4PoolsInput, _a2 func(*ec2.DescribePublicIpv4PoolsOutput, 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, *ec2.DescribePublicIpv4PoolsInput, func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribePublicIpv4PoolsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribePublicIpv4PoolsRequest(_a0 *ec2.DescribePublicIpv4PoolsInput) (*request.Request, *ec2.DescribePublicIpv4PoolsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribePublicIpv4PoolsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribePublicIpv4PoolsInput) *ec2.DescribePublicIpv4PoolsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribePublicIpv4PoolsOutput)
		}
	}

	return r0, r1
}

// DescribePublicIpv4PoolsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribePublicIpv4PoolsWithContext(_a0 context.Context, _a1 *ec2.DescribePublicIpv4PoolsInput, _a2 ...request.Option) (*ec2.DescribePublicIpv4PoolsOutput, 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 *ec2.DescribePublicIpv4PoolsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePublicIpv4PoolsInput, ...request.Option) *ec2.DescribePublicIpv4PoolsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePublicIpv4PoolsOutput)
		}
	}

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

	return r0, r1
}

// DescribeRegions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeRegions(_a0 *ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeRegionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeRegionsInput) *ec2.DescribeRegionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRegionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeRegionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeRegionsRequest(_a0 *ec2.DescribeRegionsInput) (*request.Request, *ec2.DescribeRegionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeRegionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeRegionsInput) *ec2.DescribeRegionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeRegionsOutput)
		}
	}

	return r0, r1
}

// DescribeRegionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeRegionsWithContext(_a0 context.Context, _a1 *ec2.DescribeRegionsInput, _a2 ...request.Option) (*ec2.DescribeRegionsOutput, 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 *ec2.DescribeRegionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRegionsInput, ...request.Option) *ec2.DescribeRegionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRegionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReplaceRootVolumeTasks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReplaceRootVolumeTasks(_a0 *ec2.DescribeReplaceRootVolumeTasksInput) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeReplaceRootVolumeTasksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeReplaceRootVolumeTasksInput) *ec2.DescribeReplaceRootVolumeTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReplaceRootVolumeTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeReplaceRootVolumeTasksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeReplaceRootVolumeTasksPages(_a0 *ec2.DescribeReplaceRootVolumeTasksInput, _a1 func(*ec2.DescribeReplaceRootVolumeTasksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeReplaceRootVolumeTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeReplaceRootVolumeTasksPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeReplaceRootVolumeTasksInput, _a2 func(*ec2.DescribeReplaceRootVolumeTasksOutput, 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, *ec2.DescribeReplaceRootVolumeTasksInput, func(*ec2.DescribeReplaceRootVolumeTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReplaceRootVolumeTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReplaceRootVolumeTasksRequest(_a0 *ec2.DescribeReplaceRootVolumeTasksInput) (*request.Request, *ec2.DescribeReplaceRootVolumeTasksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeReplaceRootVolumeTasksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeReplaceRootVolumeTasksInput) *ec2.DescribeReplaceRootVolumeTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeReplaceRootVolumeTasksOutput)
		}
	}

	return r0, r1
}

// DescribeReplaceRootVolumeTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeReplaceRootVolumeTasksWithContext(_a0 context.Context, _a1 *ec2.DescribeReplaceRootVolumeTasksInput, _a2 ...request.Option) (*ec2.DescribeReplaceRootVolumeTasksOutput, 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 *ec2.DescribeReplaceRootVolumeTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReplaceRootVolumeTasksInput, ...request.Option) *ec2.DescribeReplaceRootVolumeTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReplaceRootVolumeTasksOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReservedInstances(_a0 *ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeReservedInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeReservedInstancesInput) *ec2.DescribeReservedInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedInstancesListings provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReservedInstancesListings(_a0 *ec2.DescribeReservedInstancesListingsInput) (*ec2.DescribeReservedInstancesListingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeReservedInstancesListingsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeReservedInstancesListingsInput) *ec2.DescribeReservedInstancesListingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesListingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedInstancesListingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReservedInstancesListingsRequest(_a0 *ec2.DescribeReservedInstancesListingsInput) (*request.Request, *ec2.DescribeReservedInstancesListingsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeReservedInstancesListingsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeReservedInstancesListingsInput) *ec2.DescribeReservedInstancesListingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeReservedInstancesListingsOutput)
		}
	}

	return r0, r1
}

// DescribeReservedInstancesListingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeReservedInstancesListingsWithContext(_a0 context.Context, _a1 *ec2.DescribeReservedInstancesListingsInput, _a2 ...request.Option) (*ec2.DescribeReservedInstancesListingsOutput, 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 *ec2.DescribeReservedInstancesListingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesListingsInput, ...request.Option) *ec2.DescribeReservedInstancesListingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesListingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedInstancesModifications provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReservedInstancesModifications(_a0 *ec2.DescribeReservedInstancesModificationsInput) (*ec2.DescribeReservedInstancesModificationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeReservedInstancesModificationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeReservedInstancesModificationsInput) *ec2.DescribeReservedInstancesModificationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesModificationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedInstancesModificationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeReservedInstancesModificationsPages(_a0 *ec2.DescribeReservedInstancesModificationsInput, _a1 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeReservedInstancesModificationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeReservedInstancesModificationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeReservedInstancesModificationsInput, _a2 func(*ec2.DescribeReservedInstancesModificationsOutput, 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, *ec2.DescribeReservedInstancesModificationsInput, func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReservedInstancesModificationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReservedInstancesModificationsRequest(_a0 *ec2.DescribeReservedInstancesModificationsInput) (*request.Request, *ec2.DescribeReservedInstancesModificationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeReservedInstancesModificationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeReservedInstancesModificationsInput) *ec2.DescribeReservedInstancesModificationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeReservedInstancesModificationsOutput)
		}
	}

	return r0, r1
}

// DescribeReservedInstancesModificationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeReservedInstancesModificationsWithContext(_a0 context.Context, _a1 *ec2.DescribeReservedInstancesModificationsInput, _a2 ...request.Option) (*ec2.DescribeReservedInstancesModificationsOutput, 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 *ec2.DescribeReservedInstancesModificationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesModificationsInput, ...request.Option) *ec2.DescribeReservedInstancesModificationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesModificationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedInstancesOfferings provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReservedInstancesOfferings(_a0 *ec2.DescribeReservedInstancesOfferingsInput) (*ec2.DescribeReservedInstancesOfferingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeReservedInstancesOfferingsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeReservedInstancesOfferingsInput) *ec2.DescribeReservedInstancesOfferingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesOfferingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedInstancesOfferingsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeReservedInstancesOfferingsPages(_a0 *ec2.DescribeReservedInstancesOfferingsInput, _a1 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeReservedInstancesOfferingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeReservedInstancesOfferingsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeReservedInstancesOfferingsInput, _a2 func(*ec2.DescribeReservedInstancesOfferingsOutput, 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, *ec2.DescribeReservedInstancesOfferingsInput, func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReservedInstancesOfferingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReservedInstancesOfferingsRequest(_a0 *ec2.DescribeReservedInstancesOfferingsInput) (*request.Request, *ec2.DescribeReservedInstancesOfferingsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeReservedInstancesOfferingsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeReservedInstancesOfferingsInput) *ec2.DescribeReservedInstancesOfferingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeReservedInstancesOfferingsOutput)
		}
	}

	return r0, r1
}

// DescribeReservedInstancesOfferingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeReservedInstancesOfferingsWithContext(_a0 context.Context, _a1 *ec2.DescribeReservedInstancesOfferingsInput, _a2 ...request.Option) (*ec2.DescribeReservedInstancesOfferingsOutput, 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 *ec2.DescribeReservedInstancesOfferingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesOfferingsInput, ...request.Option) *ec2.DescribeReservedInstancesOfferingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesOfferingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeReservedInstancesRequest(_a0 *ec2.DescribeReservedInstancesInput) (*request.Request, *ec2.DescribeReservedInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeReservedInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeReservedInstancesInput) *ec2.DescribeReservedInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeReservedInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeReservedInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeReservedInstancesWithContext(_a0 context.Context, _a1 *ec2.DescribeReservedInstancesInput, _a2 ...request.Option) (*ec2.DescribeReservedInstancesOutput, 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 *ec2.DescribeReservedInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesInput, ...request.Option) *ec2.DescribeReservedInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeRouteTables provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeRouteTables(_a0 *ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeRouteTablesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeRouteTablesInput) *ec2.DescribeRouteTablesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRouteTablesOutput)
		}
	}

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

	return r0, r1
}

// DescribeRouteTablesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeRouteTablesPages(_a0 *ec2.DescribeRouteTablesInput, _a1 func(*ec2.DescribeRouteTablesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeRouteTablesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeRouteTablesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeRouteTablesInput, _a2 func(*ec2.DescribeRouteTablesOutput, 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, *ec2.DescribeRouteTablesInput, func(*ec2.DescribeRouteTablesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeRouteTablesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeRouteTablesRequest(_a0 *ec2.DescribeRouteTablesInput) (*request.Request, *ec2.DescribeRouteTablesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeRouteTablesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeRouteTablesInput) *ec2.DescribeRouteTablesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeRouteTablesOutput)
		}
	}

	return r0, r1
}

// DescribeRouteTablesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeRouteTablesWithContext(_a0 context.Context, _a1 *ec2.DescribeRouteTablesInput, _a2 ...request.Option) (*ec2.DescribeRouteTablesOutput, 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 *ec2.DescribeRouteTablesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteTablesInput, ...request.Option) *ec2.DescribeRouteTablesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRouteTablesOutput)
		}
	}

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

	return r0, r1
}

// DescribeScheduledInstanceAvailability provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeScheduledInstanceAvailability(_a0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeScheduledInstanceAvailabilityOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeScheduledInstanceAvailabilityInput) *ec2.DescribeScheduledInstanceAvailabilityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeScheduledInstanceAvailabilityOutput)
		}
	}

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

	return r0, r1
}

// DescribeScheduledInstanceAvailabilityPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeScheduledInstanceAvailabilityPages(_a0 *ec2.DescribeScheduledInstanceAvailabilityInput, _a1 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeScheduledInstanceAvailabilityPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeScheduledInstanceAvailabilityPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeScheduledInstanceAvailabilityInput, _a2 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, 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, *ec2.DescribeScheduledInstanceAvailabilityInput, func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeScheduledInstanceAvailabilityRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeScheduledInstanceAvailabilityRequest(_a0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*request.Request, *ec2.DescribeScheduledInstanceAvailabilityOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeScheduledInstanceAvailabilityOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeScheduledInstanceAvailabilityInput) *ec2.DescribeScheduledInstanceAvailabilityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeScheduledInstanceAvailabilityOutput)
		}
	}

	return r0, r1
}

// DescribeScheduledInstanceAvailabilityWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeScheduledInstanceAvailabilityWithContext(_a0 context.Context, _a1 *ec2.DescribeScheduledInstanceAvailabilityInput, _a2 ...request.Option) (*ec2.DescribeScheduledInstanceAvailabilityOutput, 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 *ec2.DescribeScheduledInstanceAvailabilityOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeScheduledInstanceAvailabilityInput, ...request.Option) *ec2.DescribeScheduledInstanceAvailabilityOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeScheduledInstanceAvailabilityOutput)
		}
	}

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

	return r0, r1
}

// DescribeScheduledInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeScheduledInstances(_a0 *ec2.DescribeScheduledInstancesInput) (*ec2.DescribeScheduledInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeScheduledInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeScheduledInstancesInput) *ec2.DescribeScheduledInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeScheduledInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeScheduledInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeScheduledInstancesPages(_a0 *ec2.DescribeScheduledInstancesInput, _a1 func(*ec2.DescribeScheduledInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeScheduledInstancesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeScheduledInstancesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeScheduledInstancesInput, _a2 func(*ec2.DescribeScheduledInstancesOutput, 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, *ec2.DescribeScheduledInstancesInput, func(*ec2.DescribeScheduledInstancesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeScheduledInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeScheduledInstancesRequest(_a0 *ec2.DescribeScheduledInstancesInput) (*request.Request, *ec2.DescribeScheduledInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeScheduledInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeScheduledInstancesInput) *ec2.DescribeScheduledInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeScheduledInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeScheduledInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeScheduledInstancesWithContext(_a0 context.Context, _a1 *ec2.DescribeScheduledInstancesInput, _a2 ...request.Option) (*ec2.DescribeScheduledInstancesOutput, 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 *ec2.DescribeScheduledInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeScheduledInstancesInput, ...request.Option) *ec2.DescribeScheduledInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeScheduledInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeSecurityGroupReferences provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSecurityGroupReferences(_a0 *ec2.DescribeSecurityGroupReferencesInput) (*ec2.DescribeSecurityGroupReferencesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSecurityGroupReferencesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSecurityGroupReferencesInput) *ec2.DescribeSecurityGroupReferencesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSecurityGroupReferencesOutput)
		}
	}

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

	return r0, r1
}

// DescribeSecurityGroupReferencesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSecurityGroupReferencesRequest(_a0 *ec2.DescribeSecurityGroupReferencesInput) (*request.Request, *ec2.DescribeSecurityGroupReferencesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeSecurityGroupReferencesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSecurityGroupReferencesInput) *ec2.DescribeSecurityGroupReferencesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSecurityGroupReferencesOutput)
		}
	}

	return r0, r1
}

// DescribeSecurityGroupReferencesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSecurityGroupReferencesWithContext(_a0 context.Context, _a1 *ec2.DescribeSecurityGroupReferencesInput, _a2 ...request.Option) (*ec2.DescribeSecurityGroupReferencesOutput, 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 *ec2.DescribeSecurityGroupReferencesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupReferencesInput, ...request.Option) *ec2.DescribeSecurityGroupReferencesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSecurityGroupReferencesOutput)
		}
	}

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

	return r0, r1
}

// DescribeSecurityGroups provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSecurityGroups(_a0 *ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSecurityGroupsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSecurityGroupsInput) *ec2.DescribeSecurityGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSecurityGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeSecurityGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeSecurityGroupsPages(_a0 *ec2.DescribeSecurityGroupsInput, _a1 func(*ec2.DescribeSecurityGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeSecurityGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeSecurityGroupsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeSecurityGroupsInput, _a2 func(*ec2.DescribeSecurityGroupsOutput, 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, *ec2.DescribeSecurityGroupsInput, func(*ec2.DescribeSecurityGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSecurityGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSecurityGroupsRequest(_a0 *ec2.DescribeSecurityGroupsInput) (*request.Request, *ec2.DescribeSecurityGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *ec2.DescribeSecurityGroupsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSecurityGroupsInput) *ec2.DescribeSecurityGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSecurityGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeSecurityGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSecurityGroupsWithContext(_a0 context.Context, _a1 *ec2.DescribeSecurityGroupsInput, _a2 ...request.Option) (*ec2.DescribeSecurityGroupsOutput, 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 *ec2.DescribeSecurityGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupsInput, ...request.Option) *ec2.DescribeSecurityGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSecurityGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSecurityGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSnapshotAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSnapshotAttribute(_a0 *ec2.DescribeSnapshotAttributeInput) (*ec2.DescribeSnapshotAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSnapshotAttributeInput) *ec2.DescribeSnapshotAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSnapshotAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSnapshotAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSnapshotAttributeRequest(_a0 *ec2.DescribeSnapshotAttributeInput) (*request.Request, *ec2.DescribeSnapshotAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSnapshotAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSnapshotAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSnapshotAttributeInput) *ec2.DescribeSnapshotAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSnapshotAttributeOutput)
		}
	}

	return r0, r1
}

// DescribeSnapshotAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSnapshotAttributeWithContext(_a0 context.Context, _a1 *ec2.DescribeSnapshotAttributeInput, _a2 ...request.Option) (*ec2.DescribeSnapshotAttributeOutput, 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 *ec2.DescribeSnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSnapshotAttributeInput, ...request.Option) *ec2.DescribeSnapshotAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSnapshotAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSnapshots provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSnapshots(_a0 *ec2.DescribeSnapshotsInput) (*ec2.DescribeSnapshotsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSnapshotsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSnapshotsInput) *ec2.DescribeSnapshotsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSnapshotsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSnapshotsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSnapshotsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeSnapshotsPages(_a0 *ec2.DescribeSnapshotsInput, _a1 func(*ec2.DescribeSnapshotsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSnapshotsInput, func(*ec2.DescribeSnapshotsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSnapshotsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeSnapshotsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeSnapshotsInput, _a2 func(*ec2.DescribeSnapshotsOutput, 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, *ec2.DescribeSnapshotsInput, func(*ec2.DescribeSnapshotsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSnapshotsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSnapshotsRequest(_a0 *ec2.DescribeSnapshotsInput) (*request.Request, *ec2.DescribeSnapshotsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSnapshotsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSnapshotsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSnapshotsInput) *ec2.DescribeSnapshotsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSnapshotsOutput)
		}
	}

	return r0, r1
}

// DescribeSnapshotsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSnapshotsWithContext(_a0 context.Context, _a1 *ec2.DescribeSnapshotsInput, _a2 ...request.Option) (*ec2.DescribeSnapshotsOutput, 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 *ec2.DescribeSnapshotsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSnapshotsInput, ...request.Option) *ec2.DescribeSnapshotsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSnapshotsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSnapshotsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotDatafeedSubscription provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotDatafeedSubscription(_a0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotDatafeedSubscriptionInput) *ec2.DescribeSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotDatafeedSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotDatafeedSubscriptionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotDatafeedSubscriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotDatafeedSubscriptionRequest(_a0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotDatafeedSubscriptionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotDatafeedSubscriptionInput) *ec2.DescribeSpotDatafeedSubscriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSpotDatafeedSubscriptionOutput)
		}
	}

	return r0, r1
}

// DescribeSpotDatafeedSubscriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSpotDatafeedSubscriptionWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotDatafeedSubscriptionInput, _a2 ...request.Option) (*ec2.DescribeSpotDatafeedSubscriptionOutput, 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 *ec2.DescribeSpotDatafeedSubscriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotDatafeedSubscriptionInput, ...request.Option) *ec2.DescribeSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotDatafeedSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotDatafeedSubscriptionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotFleetInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotFleetInstances(_a0 *ec2.DescribeSpotFleetInstancesInput) (*ec2.DescribeSpotFleetInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSpotFleetInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotFleetInstancesInput) *ec2.DescribeSpotFleetInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotFleetInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotFleetInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotFleetInstancesRequest(_a0 *ec2.DescribeSpotFleetInstancesInput) (*request.Request, *ec2.DescribeSpotFleetInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotFleetInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSpotFleetInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotFleetInstancesInput) *ec2.DescribeSpotFleetInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSpotFleetInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeSpotFleetInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSpotFleetInstancesWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotFleetInstancesInput, _a2 ...request.Option) (*ec2.DescribeSpotFleetInstancesOutput, 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 *ec2.DescribeSpotFleetInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetInstancesInput, ...request.Option) *ec2.DescribeSpotFleetInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotFleetInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotFleetRequestHistory provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotFleetRequestHistory(_a0 *ec2.DescribeSpotFleetRequestHistoryInput) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSpotFleetRequestHistoryOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotFleetRequestHistoryInput) *ec2.DescribeSpotFleetRequestHistoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetRequestHistoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotFleetRequestHistoryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotFleetRequestHistoryRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotFleetRequestHistoryRequest(_a0 *ec2.DescribeSpotFleetRequestHistoryInput) (*request.Request, *ec2.DescribeSpotFleetRequestHistoryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotFleetRequestHistoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSpotFleetRequestHistoryOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotFleetRequestHistoryInput) *ec2.DescribeSpotFleetRequestHistoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSpotFleetRequestHistoryOutput)
		}
	}

	return r0, r1
}

// DescribeSpotFleetRequestHistoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSpotFleetRequestHistoryWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotFleetRequestHistoryInput, _a2 ...request.Option) (*ec2.DescribeSpotFleetRequestHistoryOutput, 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 *ec2.DescribeSpotFleetRequestHistoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetRequestHistoryInput, ...request.Option) *ec2.DescribeSpotFleetRequestHistoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetRequestHistoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotFleetRequestHistoryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotFleetRequests provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotFleetRequests(_a0 *ec2.DescribeSpotFleetRequestsInput) (*ec2.DescribeSpotFleetRequestsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSpotFleetRequestsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotFleetRequestsInput) *ec2.DescribeSpotFleetRequestsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetRequestsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotFleetRequestsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotFleetRequestsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeSpotFleetRequestsPages(_a0 *ec2.DescribeSpotFleetRequestsInput, _a1 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotFleetRequestsInput, func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSpotFleetRequestsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeSpotFleetRequestsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotFleetRequestsInput, _a2 func(*ec2.DescribeSpotFleetRequestsOutput, 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, *ec2.DescribeSpotFleetRequestsInput, func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSpotFleetRequestsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotFleetRequestsRequest(_a0 *ec2.DescribeSpotFleetRequestsInput) (*request.Request, *ec2.DescribeSpotFleetRequestsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotFleetRequestsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSpotFleetRequestsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotFleetRequestsInput) *ec2.DescribeSpotFleetRequestsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSpotFleetRequestsOutput)
		}
	}

	return r0, r1
}

// DescribeSpotFleetRequestsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSpotFleetRequestsWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotFleetRequestsInput, _a2 ...request.Option) (*ec2.DescribeSpotFleetRequestsOutput, 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 *ec2.DescribeSpotFleetRequestsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetRequestsInput, ...request.Option) *ec2.DescribeSpotFleetRequestsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetRequestsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotFleetRequestsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotInstanceRequests provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotInstanceRequests(_a0 *ec2.DescribeSpotInstanceRequestsInput) (*ec2.DescribeSpotInstanceRequestsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSpotInstanceRequestsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotInstanceRequestsInput) *ec2.DescribeSpotInstanceRequestsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotInstanceRequestsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotInstanceRequestsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotInstanceRequestsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeSpotInstanceRequestsPages(_a0 *ec2.DescribeSpotInstanceRequestsInput, _a1 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotInstanceRequestsInput, func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSpotInstanceRequestsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeSpotInstanceRequestsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotInstanceRequestsInput, _a2 func(*ec2.DescribeSpotInstanceRequestsOutput, 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, *ec2.DescribeSpotInstanceRequestsInput, func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSpotInstanceRequestsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotInstanceRequestsRequest(_a0 *ec2.DescribeSpotInstanceRequestsInput) (*request.Request, *ec2.DescribeSpotInstanceRequestsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotInstanceRequestsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSpotInstanceRequestsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotInstanceRequestsInput) *ec2.DescribeSpotInstanceRequestsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSpotInstanceRequestsOutput)
		}
	}

	return r0, r1
}

// DescribeSpotInstanceRequestsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSpotInstanceRequestsWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotInstanceRequestsInput, _a2 ...request.Option) (*ec2.DescribeSpotInstanceRequestsOutput, 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 *ec2.DescribeSpotInstanceRequestsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotInstanceRequestsInput, ...request.Option) *ec2.DescribeSpotInstanceRequestsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotInstanceRequestsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotInstanceRequestsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotPriceHistory provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotPriceHistory(_a0 *ec2.DescribeSpotPriceHistoryInput) (*ec2.DescribeSpotPriceHistoryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSpotPriceHistoryOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotPriceHistoryInput) *ec2.DescribeSpotPriceHistoryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotPriceHistoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotPriceHistoryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSpotPriceHistoryPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeSpotPriceHistoryPages(_a0 *ec2.DescribeSpotPriceHistoryInput, _a1 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotPriceHistoryInput, func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSpotPriceHistoryPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeSpotPriceHistoryPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotPriceHistoryInput, _a2 func(*ec2.DescribeSpotPriceHistoryOutput, 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, *ec2.DescribeSpotPriceHistoryInput, func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSpotPriceHistoryRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSpotPriceHistoryRequest(_a0 *ec2.DescribeSpotPriceHistoryInput) (*request.Request, *ec2.DescribeSpotPriceHistoryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotPriceHistoryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSpotPriceHistoryOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSpotPriceHistoryInput) *ec2.DescribeSpotPriceHistoryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSpotPriceHistoryOutput)
		}
	}

	return r0, r1
}

// DescribeSpotPriceHistoryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSpotPriceHistoryWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotPriceHistoryInput, _a2 ...request.Option) (*ec2.DescribeSpotPriceHistoryOutput, 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 *ec2.DescribeSpotPriceHistoryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotPriceHistoryInput, ...request.Option) *ec2.DescribeSpotPriceHistoryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotPriceHistoryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotPriceHistoryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeStaleSecurityGroups provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeStaleSecurityGroups(_a0 *ec2.DescribeStaleSecurityGroupsInput) (*ec2.DescribeStaleSecurityGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeStaleSecurityGroupsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeStaleSecurityGroupsInput) *ec2.DescribeStaleSecurityGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeStaleSecurityGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeStaleSecurityGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeStaleSecurityGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeStaleSecurityGroupsPages(_a0 *ec2.DescribeStaleSecurityGroupsInput, _a1 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeStaleSecurityGroupsInput, func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeStaleSecurityGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeStaleSecurityGroupsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeStaleSecurityGroupsInput, _a2 func(*ec2.DescribeStaleSecurityGroupsOutput, 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, *ec2.DescribeStaleSecurityGroupsInput, func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeStaleSecurityGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeStaleSecurityGroupsRequest(_a0 *ec2.DescribeStaleSecurityGroupsInput) (*request.Request, *ec2.DescribeStaleSecurityGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeStaleSecurityGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeStaleSecurityGroupsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeStaleSecurityGroupsInput) *ec2.DescribeStaleSecurityGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeStaleSecurityGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeStaleSecurityGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeStaleSecurityGroupsWithContext(_a0 context.Context, _a1 *ec2.DescribeStaleSecurityGroupsInput, _a2 ...request.Option) (*ec2.DescribeStaleSecurityGroupsOutput, 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 *ec2.DescribeStaleSecurityGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeStaleSecurityGroupsInput, ...request.Option) *ec2.DescribeStaleSecurityGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeStaleSecurityGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeStaleSecurityGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeStoreImageTasks provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeStoreImageTasks(_a0 *ec2.DescribeStoreImageTasksInput) (*ec2.DescribeStoreImageTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeStoreImageTasksOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeStoreImageTasksInput) *ec2.DescribeStoreImageTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeStoreImageTasksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeStoreImageTasksInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeStoreImageTasksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeStoreImageTasksPages(_a0 *ec2.DescribeStoreImageTasksInput, _a1 func(*ec2.DescribeStoreImageTasksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeStoreImageTasksInput, func(*ec2.DescribeStoreImageTasksOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeStoreImageTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeStoreImageTasksPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeStoreImageTasksInput, _a2 func(*ec2.DescribeStoreImageTasksOutput, 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, *ec2.DescribeStoreImageTasksInput, func(*ec2.DescribeStoreImageTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeStoreImageTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeStoreImageTasksRequest(_a0 *ec2.DescribeStoreImageTasksInput) (*request.Request, *ec2.DescribeStoreImageTasksOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeStoreImageTasksInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeStoreImageTasksOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeStoreImageTasksInput) *ec2.DescribeStoreImageTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeStoreImageTasksOutput)
		}
	}

	return r0, r1
}

// DescribeStoreImageTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeStoreImageTasksWithContext(_a0 context.Context, _a1 *ec2.DescribeStoreImageTasksInput, _a2 ...request.Option) (*ec2.DescribeStoreImageTasksOutput, 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 *ec2.DescribeStoreImageTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeStoreImageTasksInput, ...request.Option) *ec2.DescribeStoreImageTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeStoreImageTasksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeStoreImageTasksInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSubnets provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSubnets(_a0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeSubnetsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSubnetsInput) *ec2.DescribeSubnetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSubnetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSubnetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSubnetsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeSubnetsPages(_a0 *ec2.DescribeSubnetsInput, _a1 func(*ec2.DescribeSubnetsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSubnetsInput, func(*ec2.DescribeSubnetsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSubnetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeSubnetsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeSubnetsInput, _a2 func(*ec2.DescribeSubnetsOutput, 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, *ec2.DescribeSubnetsInput, func(*ec2.DescribeSubnetsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSubnetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeSubnetsRequest(_a0 *ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSubnetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeSubnetsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeSubnetsInput) *ec2.DescribeSubnetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeSubnetsOutput)
		}
	}

	return r0, r1
}

// DescribeSubnetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeSubnetsWithContext(_a0 context.Context, _a1 *ec2.DescribeSubnetsInput, _a2 ...request.Option) (*ec2.DescribeSubnetsOutput, 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 *ec2.DescribeSubnetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSubnetsInput, ...request.Option) *ec2.DescribeSubnetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSubnetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSubnetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTags provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTags(_a0 *ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTagsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTagsInput) *ec2.DescribeTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTagsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTagsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTagsPages(_a0 *ec2.DescribeTagsInput, _a1 func(*ec2.DescribeTagsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTagsInput, func(*ec2.DescribeTagsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTagsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTagsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTagsInput, _a2 func(*ec2.DescribeTagsOutput, 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, *ec2.DescribeTagsInput, func(*ec2.DescribeTagsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTagsRequest(_a0 *ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTagsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTagsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTagsInput) *ec2.DescribeTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTagsOutput)
		}
	}

	return r0, r1
}

// DescribeTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTagsWithContext(_a0 context.Context, _a1 *ec2.DescribeTagsInput, _a2 ...request.Option) (*ec2.DescribeTagsOutput, 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 *ec2.DescribeTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTagsInput, ...request.Option) *ec2.DescribeTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTagsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrafficMirrorFilters provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTrafficMirrorFilters(_a0 *ec2.DescribeTrafficMirrorFiltersInput) (*ec2.DescribeTrafficMirrorFiltersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTrafficMirrorFiltersOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorFiltersInput) *ec2.DescribeTrafficMirrorFiltersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorFiltersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTrafficMirrorFiltersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrafficMirrorFiltersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTrafficMirrorFiltersPages(_a0 *ec2.DescribeTrafficMirrorFiltersInput, _a1 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorFiltersInput, func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTrafficMirrorFiltersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTrafficMirrorFiltersPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTrafficMirrorFiltersInput, _a2 func(*ec2.DescribeTrafficMirrorFiltersOutput, 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, *ec2.DescribeTrafficMirrorFiltersInput, func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTrafficMirrorFiltersRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTrafficMirrorFiltersRequest(_a0 *ec2.DescribeTrafficMirrorFiltersInput) (*request.Request, *ec2.DescribeTrafficMirrorFiltersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorFiltersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTrafficMirrorFiltersOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTrafficMirrorFiltersInput) *ec2.DescribeTrafficMirrorFiltersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTrafficMirrorFiltersOutput)
		}
	}

	return r0, r1
}

// DescribeTrafficMirrorFiltersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTrafficMirrorFiltersWithContext(_a0 context.Context, _a1 *ec2.DescribeTrafficMirrorFiltersInput, _a2 ...request.Option) (*ec2.DescribeTrafficMirrorFiltersOutput, 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 *ec2.DescribeTrafficMirrorFiltersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorFiltersInput, ...request.Option) *ec2.DescribeTrafficMirrorFiltersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorFiltersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrafficMirrorFiltersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrafficMirrorSessions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTrafficMirrorSessions(_a0 *ec2.DescribeTrafficMirrorSessionsInput) (*ec2.DescribeTrafficMirrorSessionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTrafficMirrorSessionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorSessionsInput) *ec2.DescribeTrafficMirrorSessionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorSessionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTrafficMirrorSessionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrafficMirrorSessionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTrafficMirrorSessionsPages(_a0 *ec2.DescribeTrafficMirrorSessionsInput, _a1 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorSessionsInput, func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTrafficMirrorSessionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTrafficMirrorSessionsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTrafficMirrorSessionsInput, _a2 func(*ec2.DescribeTrafficMirrorSessionsOutput, 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, *ec2.DescribeTrafficMirrorSessionsInput, func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTrafficMirrorSessionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTrafficMirrorSessionsRequest(_a0 *ec2.DescribeTrafficMirrorSessionsInput) (*request.Request, *ec2.DescribeTrafficMirrorSessionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorSessionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTrafficMirrorSessionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTrafficMirrorSessionsInput) *ec2.DescribeTrafficMirrorSessionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTrafficMirrorSessionsOutput)
		}
	}

	return r0, r1
}

// DescribeTrafficMirrorSessionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTrafficMirrorSessionsWithContext(_a0 context.Context, _a1 *ec2.DescribeTrafficMirrorSessionsInput, _a2 ...request.Option) (*ec2.DescribeTrafficMirrorSessionsOutput, 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 *ec2.DescribeTrafficMirrorSessionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorSessionsInput, ...request.Option) *ec2.DescribeTrafficMirrorSessionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorSessionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrafficMirrorSessionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrafficMirrorTargets provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTrafficMirrorTargets(_a0 *ec2.DescribeTrafficMirrorTargetsInput) (*ec2.DescribeTrafficMirrorTargetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTrafficMirrorTargetsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorTargetsInput) *ec2.DescribeTrafficMirrorTargetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorTargetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTrafficMirrorTargetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrafficMirrorTargetsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTrafficMirrorTargetsPages(_a0 *ec2.DescribeTrafficMirrorTargetsInput, _a1 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorTargetsInput, func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTrafficMirrorTargetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTrafficMirrorTargetsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTrafficMirrorTargetsInput, _a2 func(*ec2.DescribeTrafficMirrorTargetsOutput, 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, *ec2.DescribeTrafficMirrorTargetsInput, func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTrafficMirrorTargetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTrafficMirrorTargetsRequest(_a0 *ec2.DescribeTrafficMirrorTargetsInput) (*request.Request, *ec2.DescribeTrafficMirrorTargetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrafficMirrorTargetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTrafficMirrorTargetsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTrafficMirrorTargetsInput) *ec2.DescribeTrafficMirrorTargetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTrafficMirrorTargetsOutput)
		}
	}

	return r0, r1
}

// DescribeTrafficMirrorTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTrafficMirrorTargetsWithContext(_a0 context.Context, _a1 *ec2.DescribeTrafficMirrorTargetsInput, _a2 ...request.Option) (*ec2.DescribeTrafficMirrorTargetsOutput, 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 *ec2.DescribeTrafficMirrorTargetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorTargetsInput, ...request.Option) *ec2.DescribeTrafficMirrorTargetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorTargetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrafficMirrorTargetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayAttachments provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayAttachments(_a0 *ec2.DescribeTransitGatewayAttachmentsInput) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTransitGatewayAttachmentsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayAttachmentsInput) *ec2.DescribeTransitGatewayAttachmentsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayAttachmentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayAttachmentsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayAttachmentsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTransitGatewayAttachmentsPages(_a0 *ec2.DescribeTransitGatewayAttachmentsInput, _a1 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayAttachmentsInput, func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayAttachmentsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTransitGatewayAttachmentsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayAttachmentsInput, _a2 func(*ec2.DescribeTransitGatewayAttachmentsOutput, 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, *ec2.DescribeTransitGatewayAttachmentsInput, func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayAttachmentsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayAttachmentsRequest(_a0 *ec2.DescribeTransitGatewayAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayAttachmentsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayAttachmentsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTransitGatewayAttachmentsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayAttachmentsInput) *ec2.DescribeTransitGatewayAttachmentsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTransitGatewayAttachmentsOutput)
		}
	}

	return r0, r1
}

// DescribeTransitGatewayAttachmentsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTransitGatewayAttachmentsWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayAttachmentsInput, _a2 ...request.Option) (*ec2.DescribeTransitGatewayAttachmentsOutput, 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 *ec2.DescribeTransitGatewayAttachmentsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayAttachmentsInput, ...request.Option) *ec2.DescribeTransitGatewayAttachmentsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayAttachmentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayAttachmentsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayConnectPeers provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayConnectPeers(_a0 *ec2.DescribeTransitGatewayConnectPeersInput) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTransitGatewayConnectPeersOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayConnectPeersInput) *ec2.DescribeTransitGatewayConnectPeersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayConnectPeersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayConnectPeersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayConnectPeersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTransitGatewayConnectPeersPages(_a0 *ec2.DescribeTransitGatewayConnectPeersInput, _a1 func(*ec2.DescribeTransitGatewayConnectPeersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayConnectPeersInput, func(*ec2.DescribeTransitGatewayConnectPeersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayConnectPeersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTransitGatewayConnectPeersPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayConnectPeersInput, _a2 func(*ec2.DescribeTransitGatewayConnectPeersOutput, 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, *ec2.DescribeTransitGatewayConnectPeersInput, func(*ec2.DescribeTransitGatewayConnectPeersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayConnectPeersRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayConnectPeersRequest(_a0 *ec2.DescribeTransitGatewayConnectPeersInput) (*request.Request, *ec2.DescribeTransitGatewayConnectPeersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayConnectPeersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTransitGatewayConnectPeersOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayConnectPeersInput) *ec2.DescribeTransitGatewayConnectPeersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTransitGatewayConnectPeersOutput)
		}
	}

	return r0, r1
}

// DescribeTransitGatewayConnectPeersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTransitGatewayConnectPeersWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayConnectPeersInput, _a2 ...request.Option) (*ec2.DescribeTransitGatewayConnectPeersOutput, 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 *ec2.DescribeTransitGatewayConnectPeersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayConnectPeersInput, ...request.Option) *ec2.DescribeTransitGatewayConnectPeersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayConnectPeersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayConnectPeersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayConnects provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayConnects(_a0 *ec2.DescribeTransitGatewayConnectsInput) (*ec2.DescribeTransitGatewayConnectsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTransitGatewayConnectsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayConnectsInput) *ec2.DescribeTransitGatewayConnectsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayConnectsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayConnectsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayConnectsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTransitGatewayConnectsPages(_a0 *ec2.DescribeTransitGatewayConnectsInput, _a1 func(*ec2.DescribeTransitGatewayConnectsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayConnectsInput, func(*ec2.DescribeTransitGatewayConnectsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayConnectsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTransitGatewayConnectsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayConnectsInput, _a2 func(*ec2.DescribeTransitGatewayConnectsOutput, 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, *ec2.DescribeTransitGatewayConnectsInput, func(*ec2.DescribeTransitGatewayConnectsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayConnectsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayConnectsRequest(_a0 *ec2.DescribeTransitGatewayConnectsInput) (*request.Request, *ec2.DescribeTransitGatewayConnectsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayConnectsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTransitGatewayConnectsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayConnectsInput) *ec2.DescribeTransitGatewayConnectsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTransitGatewayConnectsOutput)
		}
	}

	return r0, r1
}

// DescribeTransitGatewayConnectsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTransitGatewayConnectsWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayConnectsInput, _a2 ...request.Option) (*ec2.DescribeTransitGatewayConnectsOutput, 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 *ec2.DescribeTransitGatewayConnectsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayConnectsInput, ...request.Option) *ec2.DescribeTransitGatewayConnectsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayConnectsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayConnectsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayMulticastDomains provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayMulticastDomains(_a0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTransitGatewayMulticastDomainsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayMulticastDomainsInput) *ec2.DescribeTransitGatewayMulticastDomainsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayMulticastDomainsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayMulticastDomainsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTransitGatewayMulticastDomainsPages(_a0 *ec2.DescribeTransitGatewayMulticastDomainsInput, _a1 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayMulticastDomainsInput, func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayMulticastDomainsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTransitGatewayMulticastDomainsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayMulticastDomainsInput, _a2 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, 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, *ec2.DescribeTransitGatewayMulticastDomainsInput, func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayMulticastDomainsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayMulticastDomainsRequest(_a0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*request.Request, *ec2.DescribeTransitGatewayMulticastDomainsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayMulticastDomainsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTransitGatewayMulticastDomainsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayMulticastDomainsInput) *ec2.DescribeTransitGatewayMulticastDomainsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
		}
	}

	return r0, r1
}

// DescribeTransitGatewayMulticastDomainsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTransitGatewayMulticastDomainsWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayMulticastDomainsInput, _a2 ...request.Option) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, 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 *ec2.DescribeTransitGatewayMulticastDomainsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayMulticastDomainsInput, ...request.Option) *ec2.DescribeTransitGatewayMulticastDomainsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayMulticastDomainsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayPeeringAttachments provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayPeeringAttachments(_a0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTransitGatewayPeeringAttachmentsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayPeeringAttachmentsInput) *ec2.DescribeTransitGatewayPeeringAttachmentsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayPeeringAttachmentsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayPeeringAttachmentsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTransitGatewayPeeringAttachmentsPages(_a0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, _a1 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayPeeringAttachmentsInput, func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayPeeringAttachmentsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, _a2 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, 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, *ec2.DescribeTransitGatewayPeeringAttachmentsInput, func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayPeeringAttachmentsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayPeeringAttachmentsRequest(_a0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayPeeringAttachmentsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayPeeringAttachmentsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTransitGatewayPeeringAttachmentsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayPeeringAttachmentsInput) *ec2.DescribeTransitGatewayPeeringAttachmentsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
		}
	}

	return r0, r1
}

// DescribeTransitGatewayPeeringAttachmentsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTransitGatewayPeeringAttachmentsWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, _a2 ...request.Option) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, 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 *ec2.DescribeTransitGatewayPeeringAttachmentsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayPeeringAttachmentsInput, ...request.Option) *ec2.DescribeTransitGatewayPeeringAttachmentsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayPeeringAttachmentsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayRouteTables provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayRouteTables(_a0 *ec2.DescribeTransitGatewayRouteTablesInput) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTransitGatewayRouteTablesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayRouteTablesInput) *ec2.DescribeTransitGatewayRouteTablesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayRouteTablesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayRouteTablesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayRouteTablesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTransitGatewayRouteTablesPages(_a0 *ec2.DescribeTransitGatewayRouteTablesInput, _a1 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayRouteTablesInput, func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayRouteTablesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTransitGatewayRouteTablesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayRouteTablesInput, _a2 func(*ec2.DescribeTransitGatewayRouteTablesOutput, 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, *ec2.DescribeTransitGatewayRouteTablesInput, func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayRouteTablesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayRouteTablesRequest(_a0 *ec2.DescribeTransitGatewayRouteTablesInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTablesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayRouteTablesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTransitGatewayRouteTablesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayRouteTablesInput) *ec2.DescribeTransitGatewayRouteTablesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTransitGatewayRouteTablesOutput)
		}
	}

	return r0, r1
}

// DescribeTransitGatewayRouteTablesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTransitGatewayRouteTablesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayRouteTablesInput, _a2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTablesOutput, 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 *ec2.DescribeTransitGatewayRouteTablesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayRouteTablesInput, ...request.Option) *ec2.DescribeTransitGatewayRouteTablesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayRouteTablesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayRouteTablesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayVpcAttachments provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayVpcAttachments(_a0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTransitGatewayVpcAttachmentsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayVpcAttachmentsInput) *ec2.DescribeTransitGatewayVpcAttachmentsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayVpcAttachmentsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewayVpcAttachmentsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTransitGatewayVpcAttachmentsPages(_a0 *ec2.DescribeTransitGatewayVpcAttachmentsInput, _a1 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayVpcAttachmentsInput, func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayVpcAttachmentsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTransitGatewayVpcAttachmentsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, _a2 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, 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, *ec2.DescribeTransitGatewayVpcAttachmentsInput, func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewayVpcAttachmentsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewayVpcAttachmentsRequest(_a0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayVpcAttachmentsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewayVpcAttachmentsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTransitGatewayVpcAttachmentsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewayVpcAttachmentsInput) *ec2.DescribeTransitGatewayVpcAttachmentsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
		}
	}

	return r0, r1
}

// DescribeTransitGatewayVpcAttachmentsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTransitGatewayVpcAttachmentsWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, _a2 ...request.Option) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, 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 *ec2.DescribeTransitGatewayVpcAttachmentsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayVpcAttachmentsInput, ...request.Option) *ec2.DescribeTransitGatewayVpcAttachmentsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayVpcAttachmentsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGateways provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGateways(_a0 *ec2.DescribeTransitGatewaysInput) (*ec2.DescribeTransitGatewaysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTransitGatewaysOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewaysInput) *ec2.DescribeTransitGatewaysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewaysOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewaysInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTransitGatewaysPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeTransitGatewaysPages(_a0 *ec2.DescribeTransitGatewaysInput, _a1 func(*ec2.DescribeTransitGatewaysOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewaysInput, func(*ec2.DescribeTransitGatewaysOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewaysPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeTransitGatewaysPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewaysInput, _a2 func(*ec2.DescribeTransitGatewaysOutput, 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, *ec2.DescribeTransitGatewaysInput, func(*ec2.DescribeTransitGatewaysOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeTransitGatewaysRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTransitGatewaysRequest(_a0 *ec2.DescribeTransitGatewaysInput) (*request.Request, *ec2.DescribeTransitGatewaysOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTransitGatewaysInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTransitGatewaysOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTransitGatewaysInput) *ec2.DescribeTransitGatewaysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTransitGatewaysOutput)
		}
	}

	return r0, r1
}

// DescribeTransitGatewaysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTransitGatewaysWithContext(_a0 context.Context, _a1 *ec2.DescribeTransitGatewaysInput, _a2 ...request.Option) (*ec2.DescribeTransitGatewaysOutput, 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 *ec2.DescribeTransitGatewaysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewaysInput, ...request.Option) *ec2.DescribeTransitGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewaysOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewaysInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrunkInterfaceAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTrunkInterfaceAssociations(_a0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeTrunkInterfaceAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrunkInterfaceAssociationsInput) *ec2.DescribeTrunkInterfaceAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrunkInterfaceAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTrunkInterfaceAssociationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTrunkInterfaceAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeTrunkInterfaceAssociationsRequest(_a0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*request.Request, *ec2.DescribeTrunkInterfaceAssociationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeTrunkInterfaceAssociationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeTrunkInterfaceAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeTrunkInterfaceAssociationsInput) *ec2.DescribeTrunkInterfaceAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeTrunkInterfaceAssociationsOutput)
		}
	}

	return r0, r1
}

// DescribeTrunkInterfaceAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeTrunkInterfaceAssociationsWithContext(_a0 context.Context, _a1 *ec2.DescribeTrunkInterfaceAssociationsInput, _a2 ...request.Option) (*ec2.DescribeTrunkInterfaceAssociationsOutput, 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 *ec2.DescribeTrunkInterfaceAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrunkInterfaceAssociationsInput, ...request.Option) *ec2.DescribeTrunkInterfaceAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrunkInterfaceAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrunkInterfaceAssociationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVolumeAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVolumeAttribute(_a0 *ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVolumeAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumeAttributeInput) *ec2.DescribeVolumeAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumeAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVolumeAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVolumeAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVolumeAttributeRequest(_a0 *ec2.DescribeVolumeAttributeInput) (*request.Request, *ec2.DescribeVolumeAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumeAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVolumeAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVolumeAttributeInput) *ec2.DescribeVolumeAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVolumeAttributeOutput)
		}
	}

	return r0, r1
}

// DescribeVolumeAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVolumeAttributeWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumeAttributeInput, _a2 ...request.Option) (*ec2.DescribeVolumeAttributeOutput, 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 *ec2.DescribeVolumeAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumeAttributeInput, ...request.Option) *ec2.DescribeVolumeAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumeAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVolumeAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVolumeStatus provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVolumeStatus(_a0 *ec2.DescribeVolumeStatusInput) (*ec2.DescribeVolumeStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVolumeStatusOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumeStatusInput) *ec2.DescribeVolumeStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumeStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVolumeStatusInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVolumeStatusPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVolumeStatusPages(_a0 *ec2.DescribeVolumeStatusInput, _a1 func(*ec2.DescribeVolumeStatusOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumeStatusInput, func(*ec2.DescribeVolumeStatusOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVolumeStatusPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVolumeStatusPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumeStatusInput, _a2 func(*ec2.DescribeVolumeStatusOutput, 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, *ec2.DescribeVolumeStatusInput, func(*ec2.DescribeVolumeStatusOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVolumeStatusRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVolumeStatusRequest(_a0 *ec2.DescribeVolumeStatusInput) (*request.Request, *ec2.DescribeVolumeStatusOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumeStatusInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVolumeStatusOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVolumeStatusInput) *ec2.DescribeVolumeStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVolumeStatusOutput)
		}
	}

	return r0, r1
}

// DescribeVolumeStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVolumeStatusWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumeStatusInput, _a2 ...request.Option) (*ec2.DescribeVolumeStatusOutput, 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 *ec2.DescribeVolumeStatusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumeStatusInput, ...request.Option) *ec2.DescribeVolumeStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumeStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVolumeStatusInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVolumes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVolumes(_a0 *ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVolumesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesInput) *ec2.DescribeVolumesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVolumesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVolumesModifications provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVolumesModifications(_a0 *ec2.DescribeVolumesModificationsInput) (*ec2.DescribeVolumesModificationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVolumesModificationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesModificationsInput) *ec2.DescribeVolumesModificationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumesModificationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVolumesModificationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVolumesModificationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVolumesModificationsPages(_a0 *ec2.DescribeVolumesModificationsInput, _a1 func(*ec2.DescribeVolumesModificationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesModificationsInput, func(*ec2.DescribeVolumesModificationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVolumesModificationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVolumesModificationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumesModificationsInput, _a2 func(*ec2.DescribeVolumesModificationsOutput, 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, *ec2.DescribeVolumesModificationsInput, func(*ec2.DescribeVolumesModificationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVolumesModificationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVolumesModificationsRequest(_a0 *ec2.DescribeVolumesModificationsInput) (*request.Request, *ec2.DescribeVolumesModificationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesModificationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVolumesModificationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVolumesModificationsInput) *ec2.DescribeVolumesModificationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVolumesModificationsOutput)
		}
	}

	return r0, r1
}

// DescribeVolumesModificationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVolumesModificationsWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumesModificationsInput, _a2 ...request.Option) (*ec2.DescribeVolumesModificationsOutput, 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 *ec2.DescribeVolumesModificationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumesModificationsInput, ...request.Option) *ec2.DescribeVolumesModificationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumesModificationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVolumesModificationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVolumesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVolumesPages(_a0 *ec2.DescribeVolumesInput, _a1 func(*ec2.DescribeVolumesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesInput, func(*ec2.DescribeVolumesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVolumesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVolumesPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumesInput, _a2 func(*ec2.DescribeVolumesOutput, 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, *ec2.DescribeVolumesInput, func(*ec2.DescribeVolumesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVolumesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVolumesRequest(_a0 *ec2.DescribeVolumesInput) (*request.Request, *ec2.DescribeVolumesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVolumesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVolumesInput) *ec2.DescribeVolumesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVolumesOutput)
		}
	}

	return r0, r1
}

// DescribeVolumesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVolumesWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumesInput, _a2 ...request.Option) (*ec2.DescribeVolumesOutput, 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 *ec2.DescribeVolumesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumesInput, ...request.Option) *ec2.DescribeVolumesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVolumesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcAttribute(_a0 *ec2.DescribeVpcAttributeInput) (*ec2.DescribeVpcAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcAttributeInput) *ec2.DescribeVpcAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcAttributeRequest(_a0 *ec2.DescribeVpcAttributeInput) (*request.Request, *ec2.DescribeVpcAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcAttributeInput) *ec2.DescribeVpcAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcAttributeOutput)
		}
	}

	return r0, r1
}

// DescribeVpcAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcAttributeWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcAttributeInput, _a2 ...request.Option) (*ec2.DescribeVpcAttributeOutput, 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 *ec2.DescribeVpcAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcAttributeInput, ...request.Option) *ec2.DescribeVpcAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcClassicLink provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcClassicLink(_a0 *ec2.DescribeVpcClassicLinkInput) (*ec2.DescribeVpcClassicLinkOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcClassicLinkOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcClassicLinkInput) *ec2.DescribeVpcClassicLinkOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcClassicLinkOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcClassicLinkInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcClassicLinkDnsSupport provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcClassicLinkDnsSupport(_a0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcClassicLinkDnsSupportInput) *ec2.DescribeVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcClassicLinkDnsSupportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcClassicLinkDnsSupportPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVpcClassicLinkDnsSupportPages(_a0 *ec2.DescribeVpcClassicLinkDnsSupportInput, _a1 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcClassicLinkDnsSupportInput, func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcClassicLinkDnsSupportPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVpcClassicLinkDnsSupportPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcClassicLinkDnsSupportInput, _a2 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, 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, *ec2.DescribeVpcClassicLinkDnsSupportInput, func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcClassicLinkDnsSupportRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcClassicLinkDnsSupportRequest(_a0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DescribeVpcClassicLinkDnsSupportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcClassicLinkDnsSupportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcClassicLinkDnsSupportInput) *ec2.DescribeVpcClassicLinkDnsSupportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
		}
	}

	return r0, r1
}

// DescribeVpcClassicLinkDnsSupportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcClassicLinkDnsSupportWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcClassicLinkDnsSupportInput, _a2 ...request.Option) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, 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 *ec2.DescribeVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcClassicLinkDnsSupportInput, ...request.Option) *ec2.DescribeVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcClassicLinkDnsSupportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcClassicLinkRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcClassicLinkRequest(_a0 *ec2.DescribeVpcClassicLinkInput) (*request.Request, *ec2.DescribeVpcClassicLinkOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcClassicLinkInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcClassicLinkOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcClassicLinkInput) *ec2.DescribeVpcClassicLinkOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcClassicLinkOutput)
		}
	}

	return r0, r1
}

// DescribeVpcClassicLinkWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcClassicLinkWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcClassicLinkInput, _a2 ...request.Option) (*ec2.DescribeVpcClassicLinkOutput, 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 *ec2.DescribeVpcClassicLinkOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcClassicLinkInput, ...request.Option) *ec2.DescribeVpcClassicLinkOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcClassicLinkOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcClassicLinkInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointConnectionNotifications provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionNotifications(_a0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcEndpointConnectionNotificationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointConnectionNotificationsInput) *ec2.DescribeVpcEndpointConnectionNotificationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointConnectionNotificationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointConnectionNotificationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionNotificationsPages(_a0 *ec2.DescribeVpcEndpointConnectionNotificationsInput, _a1 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointConnectionNotificationsInput, func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointConnectionNotificationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionNotificationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, _a2 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, 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, *ec2.DescribeVpcEndpointConnectionNotificationsInput, func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointConnectionNotificationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionNotificationsRequest(_a0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionNotificationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointConnectionNotificationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcEndpointConnectionNotificationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointConnectionNotificationsInput) *ec2.DescribeVpcEndpointConnectionNotificationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
		}
	}

	return r0, r1
}

// DescribeVpcEndpointConnectionNotificationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionNotificationsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, _a2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, 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 *ec2.DescribeVpcEndpointConnectionNotificationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointConnectionNotificationsInput, ...request.Option) *ec2.DescribeVpcEndpointConnectionNotificationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointConnectionNotificationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointConnections provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointConnections(_a0 *ec2.DescribeVpcEndpointConnectionsInput) (*ec2.DescribeVpcEndpointConnectionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointConnectionsInput) *ec2.DescribeVpcEndpointConnectionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointConnectionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointConnectionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionsPages(_a0 *ec2.DescribeVpcEndpointConnectionsInput, _a1 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointConnectionsInput, func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointConnectionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointConnectionsInput, _a2 func(*ec2.DescribeVpcEndpointConnectionsOutput, 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, *ec2.DescribeVpcEndpointConnectionsInput, func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointConnectionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionsRequest(_a0 *ec2.DescribeVpcEndpointConnectionsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointConnectionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointConnectionsInput) *ec2.DescribeVpcEndpointConnectionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcEndpointConnectionsOutput)
		}
	}

	return r0, r1
}

// DescribeVpcEndpointConnectionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcEndpointConnectionsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointConnectionsInput, _a2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionsOutput, 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 *ec2.DescribeVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointConnectionsInput, ...request.Option) *ec2.DescribeVpcEndpointConnectionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointConnectionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointServiceConfigurations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointServiceConfigurations(_a0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcEndpointServiceConfigurationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointServiceConfigurationsInput) *ec2.DescribeVpcEndpointServiceConfigurationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointServiceConfigurationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointServiceConfigurationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVpcEndpointServiceConfigurationsPages(_a0 *ec2.DescribeVpcEndpointServiceConfigurationsInput, _a1 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointServiceConfigurationsInput, func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointServiceConfigurationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVpcEndpointServiceConfigurationsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, _a2 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, 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, *ec2.DescribeVpcEndpointServiceConfigurationsInput, func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointServiceConfigurationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointServiceConfigurationsRequest(_a0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DescribeVpcEndpointServiceConfigurationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointServiceConfigurationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcEndpointServiceConfigurationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointServiceConfigurationsInput) *ec2.DescribeVpcEndpointServiceConfigurationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
		}
	}

	return r0, r1
}

// DescribeVpcEndpointServiceConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcEndpointServiceConfigurationsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, _a2 ...request.Option) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, 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 *ec2.DescribeVpcEndpointServiceConfigurationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServiceConfigurationsInput, ...request.Option) *ec2.DescribeVpcEndpointServiceConfigurationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointServiceConfigurationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointServicePermissions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointServicePermissions(_a0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcEndpointServicePermissionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointServicePermissionsInput) *ec2.DescribeVpcEndpointServicePermissionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServicePermissionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointServicePermissionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointServicePermissionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVpcEndpointServicePermissionsPages(_a0 *ec2.DescribeVpcEndpointServicePermissionsInput, _a1 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointServicePermissionsInput, func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointServicePermissionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVpcEndpointServicePermissionsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointServicePermissionsInput, _a2 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, 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, *ec2.DescribeVpcEndpointServicePermissionsInput, func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointServicePermissionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointServicePermissionsRequest(_a0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*request.Request, *ec2.DescribeVpcEndpointServicePermissionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointServicePermissionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcEndpointServicePermissionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointServicePermissionsInput) *ec2.DescribeVpcEndpointServicePermissionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcEndpointServicePermissionsOutput)
		}
	}

	return r0, r1
}

// DescribeVpcEndpointServicePermissionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcEndpointServicePermissionsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointServicePermissionsInput, _a2 ...request.Option) (*ec2.DescribeVpcEndpointServicePermissionsOutput, 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 *ec2.DescribeVpcEndpointServicePermissionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServicePermissionsInput, ...request.Option) *ec2.DescribeVpcEndpointServicePermissionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServicePermissionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointServicePermissionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointServices provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointServices(_a0 *ec2.DescribeVpcEndpointServicesInput) (*ec2.DescribeVpcEndpointServicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcEndpointServicesOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointServicesInput) *ec2.DescribeVpcEndpointServicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointServicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointServicesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointServicesRequest(_a0 *ec2.DescribeVpcEndpointServicesInput) (*request.Request, *ec2.DescribeVpcEndpointServicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointServicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcEndpointServicesOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointServicesInput) *ec2.DescribeVpcEndpointServicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcEndpointServicesOutput)
		}
	}

	return r0, r1
}

// DescribeVpcEndpointServicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcEndpointServicesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointServicesInput, _a2 ...request.Option) (*ec2.DescribeVpcEndpointServicesOutput, 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 *ec2.DescribeVpcEndpointServicesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServicesInput, ...request.Option) *ec2.DescribeVpcEndpointServicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointServicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpoints provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpoints(_a0 *ec2.DescribeVpcEndpointsInput) (*ec2.DescribeVpcEndpointsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcEndpointsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointsInput) *ec2.DescribeVpcEndpointsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcEndpointsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVpcEndpointsPages(_a0 *ec2.DescribeVpcEndpointsInput, _a1 func(*ec2.DescribeVpcEndpointsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointsInput, func(*ec2.DescribeVpcEndpointsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVpcEndpointsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointsInput, _a2 func(*ec2.DescribeVpcEndpointsOutput, 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, *ec2.DescribeVpcEndpointsInput, func(*ec2.DescribeVpcEndpointsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcEndpointsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcEndpointsRequest(_a0 *ec2.DescribeVpcEndpointsInput) (*request.Request, *ec2.DescribeVpcEndpointsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcEndpointsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcEndpointsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcEndpointsInput) *ec2.DescribeVpcEndpointsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcEndpointsOutput)
		}
	}

	return r0, r1
}

// DescribeVpcEndpointsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcEndpointsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcEndpointsInput, _a2 ...request.Option) (*ec2.DescribeVpcEndpointsOutput, 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 *ec2.DescribeVpcEndpointsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointsInput, ...request.Option) *ec2.DescribeVpcEndpointsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcPeeringConnections provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcPeeringConnections(_a0 *ec2.DescribeVpcPeeringConnectionsInput) (*ec2.DescribeVpcPeeringConnectionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcPeeringConnectionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcPeeringConnectionsInput) *ec2.DescribeVpcPeeringConnectionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcPeeringConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcPeeringConnectionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcPeeringConnectionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVpcPeeringConnectionsPages(_a0 *ec2.DescribeVpcPeeringConnectionsInput, _a1 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcPeeringConnectionsInput, func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcPeeringConnectionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVpcPeeringConnectionsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcPeeringConnectionsInput, _a2 func(*ec2.DescribeVpcPeeringConnectionsOutput, 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, *ec2.DescribeVpcPeeringConnectionsInput, func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcPeeringConnectionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcPeeringConnectionsRequest(_a0 *ec2.DescribeVpcPeeringConnectionsInput) (*request.Request, *ec2.DescribeVpcPeeringConnectionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcPeeringConnectionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcPeeringConnectionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcPeeringConnectionsInput) *ec2.DescribeVpcPeeringConnectionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcPeeringConnectionsOutput)
		}
	}

	return r0, r1
}

// DescribeVpcPeeringConnectionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcPeeringConnectionsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcPeeringConnectionsInput, _a2 ...request.Option) (*ec2.DescribeVpcPeeringConnectionsOutput, 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 *ec2.DescribeVpcPeeringConnectionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcPeeringConnectionsInput, ...request.Option) *ec2.DescribeVpcPeeringConnectionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcPeeringConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcPeeringConnectionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcs provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcs(_a0 *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpcsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcsInput) *ec2.DescribeVpcsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpcsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) DescribeVpcsPages(_a0 *ec2.DescribeVpcsInput, _a1 func(*ec2.DescribeVpcsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcsInput, func(*ec2.DescribeVpcsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) DescribeVpcsPagesWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcsInput, _a2 func(*ec2.DescribeVpcsOutput, 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, *ec2.DescribeVpcsInput, func(*ec2.DescribeVpcsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeVpcsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpcsRequest(_a0 *ec2.DescribeVpcsInput) (*request.Request, *ec2.DescribeVpcsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpcsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpcsInput) *ec2.DescribeVpcsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpcsOutput)
		}
	}

	return r0, r1
}

// DescribeVpcsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpcsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcsInput, _a2 ...request.Option) (*ec2.DescribeVpcsOutput, 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 *ec2.DescribeVpcsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcsInput, ...request.Option) *ec2.DescribeVpcsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpnConnections provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpnConnections(_a0 *ec2.DescribeVpnConnectionsInput) (*ec2.DescribeVpnConnectionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpnConnectionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpnConnectionsInput) *ec2.DescribeVpnConnectionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpnConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpnConnectionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpnConnectionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpnConnectionsRequest(_a0 *ec2.DescribeVpnConnectionsInput) (*request.Request, *ec2.DescribeVpnConnectionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpnConnectionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpnConnectionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpnConnectionsInput) *ec2.DescribeVpnConnectionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpnConnectionsOutput)
		}
	}

	return r0, r1
}

// DescribeVpnConnectionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpnConnectionsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpnConnectionsInput, _a2 ...request.Option) (*ec2.DescribeVpnConnectionsOutput, 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 *ec2.DescribeVpnConnectionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnConnectionsInput, ...request.Option) *ec2.DescribeVpnConnectionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpnConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpnConnectionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpnGateways provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpnGateways(_a0 *ec2.DescribeVpnGatewaysInput) (*ec2.DescribeVpnGatewaysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DescribeVpnGatewaysOutput
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpnGatewaysInput) *ec2.DescribeVpnGatewaysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpnGatewaysOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpnGatewaysInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeVpnGatewaysRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DescribeVpnGatewaysRequest(_a0 *ec2.DescribeVpnGatewaysInput) (*request.Request, *ec2.DescribeVpnGatewaysOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpnGatewaysInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DescribeVpnGatewaysOutput
	if rf, ok := ret.Get(1).(func(*ec2.DescribeVpnGatewaysInput) *ec2.DescribeVpnGatewaysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DescribeVpnGatewaysOutput)
		}
	}

	return r0, r1
}

// DescribeVpnGatewaysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DescribeVpnGatewaysWithContext(_a0 context.Context, _a1 *ec2.DescribeVpnGatewaysInput, _a2 ...request.Option) (*ec2.DescribeVpnGatewaysOutput, 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 *ec2.DescribeVpnGatewaysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnGatewaysInput, ...request.Option) *ec2.DescribeVpnGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpnGatewaysOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpnGatewaysInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachClassicLinkVpc provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachClassicLinkVpc(_a0 *ec2.DetachClassicLinkVpcInput) (*ec2.DetachClassicLinkVpcOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DetachClassicLinkVpcOutput
	if rf, ok := ret.Get(0).(func(*ec2.DetachClassicLinkVpcInput) *ec2.DetachClassicLinkVpcOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachClassicLinkVpcOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DetachClassicLinkVpcInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachClassicLinkVpcRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachClassicLinkVpcRequest(_a0 *ec2.DetachClassicLinkVpcInput) (*request.Request, *ec2.DetachClassicLinkVpcOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DetachClassicLinkVpcInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DetachClassicLinkVpcOutput
	if rf, ok := ret.Get(1).(func(*ec2.DetachClassicLinkVpcInput) *ec2.DetachClassicLinkVpcOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DetachClassicLinkVpcOutput)
		}
	}

	return r0, r1
}

// DetachClassicLinkVpcWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DetachClassicLinkVpcWithContext(_a0 context.Context, _a1 *ec2.DetachClassicLinkVpcInput, _a2 ...request.Option) (*ec2.DetachClassicLinkVpcOutput, 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 *ec2.DetachClassicLinkVpcOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachClassicLinkVpcInput, ...request.Option) *ec2.DetachClassicLinkVpcOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachClassicLinkVpcOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachClassicLinkVpcInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachInternetGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachInternetGateway(_a0 *ec2.DetachInternetGatewayInput) (*ec2.DetachInternetGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DetachInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DetachInternetGatewayInput) *ec2.DetachInternetGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachInternetGatewayOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DetachInternetGatewayInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachInternetGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachInternetGatewayRequest(_a0 *ec2.DetachInternetGatewayInput) (*request.Request, *ec2.DetachInternetGatewayOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DetachInternetGatewayInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DetachInternetGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DetachInternetGatewayInput) *ec2.DetachInternetGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DetachInternetGatewayOutput)
		}
	}

	return r0, r1
}

// DetachInternetGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DetachInternetGatewayWithContext(_a0 context.Context, _a1 *ec2.DetachInternetGatewayInput, _a2 ...request.Option) (*ec2.DetachInternetGatewayOutput, 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 *ec2.DetachInternetGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachInternetGatewayInput, ...request.Option) *ec2.DetachInternetGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachInternetGatewayOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachInternetGatewayInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachNetworkInterface provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachNetworkInterface(_a0 *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DetachNetworkInterfaceOutput
	if rf, ok := ret.Get(0).(func(*ec2.DetachNetworkInterfaceInput) *ec2.DetachNetworkInterfaceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachNetworkInterfaceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DetachNetworkInterfaceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachNetworkInterfaceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachNetworkInterfaceRequest(_a0 *ec2.DetachNetworkInterfaceInput) (*request.Request, *ec2.DetachNetworkInterfaceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DetachNetworkInterfaceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DetachNetworkInterfaceOutput
	if rf, ok := ret.Get(1).(func(*ec2.DetachNetworkInterfaceInput) *ec2.DetachNetworkInterfaceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DetachNetworkInterfaceOutput)
		}
	}

	return r0, r1
}

// DetachNetworkInterfaceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DetachNetworkInterfaceWithContext(_a0 context.Context, _a1 *ec2.DetachNetworkInterfaceInput, _a2 ...request.Option) (*ec2.DetachNetworkInterfaceOutput, 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 *ec2.DetachNetworkInterfaceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachNetworkInterfaceInput, ...request.Option) *ec2.DetachNetworkInterfaceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachNetworkInterfaceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachNetworkInterfaceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachVolume provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachVolume(_a0 *ec2.DetachVolumeInput) (*ec2.VolumeAttachment, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.VolumeAttachment
	if rf, ok := ret.Get(0).(func(*ec2.DetachVolumeInput) *ec2.VolumeAttachment); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.VolumeAttachment)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DetachVolumeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachVolumeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachVolumeRequest(_a0 *ec2.DetachVolumeInput) (*request.Request, *ec2.VolumeAttachment) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DetachVolumeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.VolumeAttachment
	if rf, ok := ret.Get(1).(func(*ec2.DetachVolumeInput) *ec2.VolumeAttachment); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.VolumeAttachment)
		}
	}

	return r0, r1
}

// DetachVolumeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DetachVolumeWithContext(_a0 context.Context, _a1 *ec2.DetachVolumeInput, _a2 ...request.Option) (*ec2.VolumeAttachment, 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 *ec2.VolumeAttachment
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachVolumeInput, ...request.Option) *ec2.VolumeAttachment); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.VolumeAttachment)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachVolumeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachVpnGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachVpnGateway(_a0 *ec2.DetachVpnGatewayInput) (*ec2.DetachVpnGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DetachVpnGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.DetachVpnGatewayInput) *ec2.DetachVpnGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachVpnGatewayOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DetachVpnGatewayInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachVpnGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DetachVpnGatewayRequest(_a0 *ec2.DetachVpnGatewayInput) (*request.Request, *ec2.DetachVpnGatewayOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DetachVpnGatewayInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DetachVpnGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.DetachVpnGatewayInput) *ec2.DetachVpnGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DetachVpnGatewayOutput)
		}
	}

	return r0, r1
}

// DetachVpnGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DetachVpnGatewayWithContext(_a0 context.Context, _a1 *ec2.DetachVpnGatewayInput, _a2 ...request.Option) (*ec2.DetachVpnGatewayOutput, 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 *ec2.DetachVpnGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachVpnGatewayInput, ...request.Option) *ec2.DetachVpnGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachVpnGatewayOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachVpnGatewayInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableEbsEncryptionByDefault provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableEbsEncryptionByDefault(_a0 *ec2.DisableEbsEncryptionByDefaultInput) (*ec2.DisableEbsEncryptionByDefaultOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisableEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisableEbsEncryptionByDefaultInput) *ec2.DisableEbsEncryptionByDefaultOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableEbsEncryptionByDefaultOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisableEbsEncryptionByDefaultInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableEbsEncryptionByDefaultRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableEbsEncryptionByDefaultRequest(_a0 *ec2.DisableEbsEncryptionByDefaultInput) (*request.Request, *ec2.DisableEbsEncryptionByDefaultOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisableEbsEncryptionByDefaultInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisableEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisableEbsEncryptionByDefaultInput) *ec2.DisableEbsEncryptionByDefaultOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisableEbsEncryptionByDefaultOutput)
		}
	}

	return r0, r1
}

// DisableEbsEncryptionByDefaultWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisableEbsEncryptionByDefaultWithContext(_a0 context.Context, _a1 *ec2.DisableEbsEncryptionByDefaultInput, _a2 ...request.Option) (*ec2.DisableEbsEncryptionByDefaultOutput, 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 *ec2.DisableEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableEbsEncryptionByDefaultInput, ...request.Option) *ec2.DisableEbsEncryptionByDefaultOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableEbsEncryptionByDefaultOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableEbsEncryptionByDefaultInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableFastSnapshotRestores provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableFastSnapshotRestores(_a0 *ec2.DisableFastSnapshotRestoresInput) (*ec2.DisableFastSnapshotRestoresOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisableFastSnapshotRestoresOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisableFastSnapshotRestoresInput) *ec2.DisableFastSnapshotRestoresOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableFastSnapshotRestoresOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisableFastSnapshotRestoresInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableFastSnapshotRestoresRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableFastSnapshotRestoresRequest(_a0 *ec2.DisableFastSnapshotRestoresInput) (*request.Request, *ec2.DisableFastSnapshotRestoresOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisableFastSnapshotRestoresInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisableFastSnapshotRestoresOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisableFastSnapshotRestoresInput) *ec2.DisableFastSnapshotRestoresOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisableFastSnapshotRestoresOutput)
		}
	}

	return r0, r1
}

// DisableFastSnapshotRestoresWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisableFastSnapshotRestoresWithContext(_a0 context.Context, _a1 *ec2.DisableFastSnapshotRestoresInput, _a2 ...request.Option) (*ec2.DisableFastSnapshotRestoresOutput, 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 *ec2.DisableFastSnapshotRestoresOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableFastSnapshotRestoresInput, ...request.Option) *ec2.DisableFastSnapshotRestoresOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableFastSnapshotRestoresOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableFastSnapshotRestoresInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableImageDeprecation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableImageDeprecation(_a0 *ec2.DisableImageDeprecationInput) (*ec2.DisableImageDeprecationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisableImageDeprecationOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisableImageDeprecationInput) *ec2.DisableImageDeprecationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableImageDeprecationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisableImageDeprecationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableImageDeprecationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableImageDeprecationRequest(_a0 *ec2.DisableImageDeprecationInput) (*request.Request, *ec2.DisableImageDeprecationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisableImageDeprecationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisableImageDeprecationOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisableImageDeprecationInput) *ec2.DisableImageDeprecationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisableImageDeprecationOutput)
		}
	}

	return r0, r1
}

// DisableImageDeprecationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisableImageDeprecationWithContext(_a0 context.Context, _a1 *ec2.DisableImageDeprecationInput, _a2 ...request.Option) (*ec2.DisableImageDeprecationOutput, 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 *ec2.DisableImageDeprecationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageDeprecationInput, ...request.Option) *ec2.DisableImageDeprecationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableImageDeprecationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableImageDeprecationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableSerialConsoleAccess provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableSerialConsoleAccess(_a0 *ec2.DisableSerialConsoleAccessInput) (*ec2.DisableSerialConsoleAccessOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisableSerialConsoleAccessOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisableSerialConsoleAccessInput) *ec2.DisableSerialConsoleAccessOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableSerialConsoleAccessOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisableSerialConsoleAccessInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableSerialConsoleAccessRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableSerialConsoleAccessRequest(_a0 *ec2.DisableSerialConsoleAccessInput) (*request.Request, *ec2.DisableSerialConsoleAccessOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisableSerialConsoleAccessInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisableSerialConsoleAccessOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisableSerialConsoleAccessInput) *ec2.DisableSerialConsoleAccessOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisableSerialConsoleAccessOutput)
		}
	}

	return r0, r1
}

// DisableSerialConsoleAccessWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisableSerialConsoleAccessWithContext(_a0 context.Context, _a1 *ec2.DisableSerialConsoleAccessInput, _a2 ...request.Option) (*ec2.DisableSerialConsoleAccessOutput, 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 *ec2.DisableSerialConsoleAccessOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableSerialConsoleAccessInput, ...request.Option) *ec2.DisableSerialConsoleAccessOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableSerialConsoleAccessOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableSerialConsoleAccessInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableTransitGatewayRouteTablePropagation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableTransitGatewayRouteTablePropagation(_a0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisableTransitGatewayRouteTablePropagationOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisableTransitGatewayRouteTablePropagationInput) *ec2.DisableTransitGatewayRouteTablePropagationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisableTransitGatewayRouteTablePropagationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableTransitGatewayRouteTablePropagationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableTransitGatewayRouteTablePropagationRequest(_a0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.DisableTransitGatewayRouteTablePropagationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisableTransitGatewayRouteTablePropagationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisableTransitGatewayRouteTablePropagationOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisableTransitGatewayRouteTablePropagationInput) *ec2.DisableTransitGatewayRouteTablePropagationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
		}
	}

	return r0, r1
}

// DisableTransitGatewayRouteTablePropagationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisableTransitGatewayRouteTablePropagationWithContext(_a0 context.Context, _a1 *ec2.DisableTransitGatewayRouteTablePropagationInput, _a2 ...request.Option) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, 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 *ec2.DisableTransitGatewayRouteTablePropagationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableTransitGatewayRouteTablePropagationInput, ...request.Option) *ec2.DisableTransitGatewayRouteTablePropagationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableTransitGatewayRouteTablePropagationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableVgwRoutePropagation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableVgwRoutePropagation(_a0 *ec2.DisableVgwRoutePropagationInput) (*ec2.DisableVgwRoutePropagationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisableVgwRoutePropagationOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisableVgwRoutePropagationInput) *ec2.DisableVgwRoutePropagationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVgwRoutePropagationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisableVgwRoutePropagationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableVgwRoutePropagationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableVgwRoutePropagationRequest(_a0 *ec2.DisableVgwRoutePropagationInput) (*request.Request, *ec2.DisableVgwRoutePropagationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisableVgwRoutePropagationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisableVgwRoutePropagationOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisableVgwRoutePropagationInput) *ec2.DisableVgwRoutePropagationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisableVgwRoutePropagationOutput)
		}
	}

	return r0, r1
}

// DisableVgwRoutePropagationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisableVgwRoutePropagationWithContext(_a0 context.Context, _a1 *ec2.DisableVgwRoutePropagationInput, _a2 ...request.Option) (*ec2.DisableVgwRoutePropagationOutput, 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 *ec2.DisableVgwRoutePropagationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVgwRoutePropagationInput, ...request.Option) *ec2.DisableVgwRoutePropagationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVgwRoutePropagationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableVgwRoutePropagationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableVpcClassicLink provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableVpcClassicLink(_a0 *ec2.DisableVpcClassicLinkInput) (*ec2.DisableVpcClassicLinkOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisableVpcClassicLinkOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisableVpcClassicLinkInput) *ec2.DisableVpcClassicLinkOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVpcClassicLinkOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisableVpcClassicLinkInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableVpcClassicLinkDnsSupport provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableVpcClassicLinkDnsSupport(_a0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisableVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisableVpcClassicLinkDnsSupportInput) *ec2.DisableVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVpcClassicLinkDnsSupportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisableVpcClassicLinkDnsSupportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableVpcClassicLinkDnsSupportRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableVpcClassicLinkDnsSupportRequest(_a0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DisableVpcClassicLinkDnsSupportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisableVpcClassicLinkDnsSupportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisableVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisableVpcClassicLinkDnsSupportInput) *ec2.DisableVpcClassicLinkDnsSupportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisableVpcClassicLinkDnsSupportOutput)
		}
	}

	return r0, r1
}

// DisableVpcClassicLinkDnsSupportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisableVpcClassicLinkDnsSupportWithContext(_a0 context.Context, _a1 *ec2.DisableVpcClassicLinkDnsSupportInput, _a2 ...request.Option) (*ec2.DisableVpcClassicLinkDnsSupportOutput, 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 *ec2.DisableVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVpcClassicLinkDnsSupportInput, ...request.Option) *ec2.DisableVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVpcClassicLinkDnsSupportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableVpcClassicLinkDnsSupportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableVpcClassicLinkRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisableVpcClassicLinkRequest(_a0 *ec2.DisableVpcClassicLinkInput) (*request.Request, *ec2.DisableVpcClassicLinkOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisableVpcClassicLinkInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisableVpcClassicLinkOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisableVpcClassicLinkInput) *ec2.DisableVpcClassicLinkOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisableVpcClassicLinkOutput)
		}
	}

	return r0, r1
}

// DisableVpcClassicLinkWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisableVpcClassicLinkWithContext(_a0 context.Context, _a1 *ec2.DisableVpcClassicLinkInput, _a2 ...request.Option) (*ec2.DisableVpcClassicLinkOutput, 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 *ec2.DisableVpcClassicLinkOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVpcClassicLinkInput, ...request.Option) *ec2.DisableVpcClassicLinkOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVpcClassicLinkOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableVpcClassicLinkInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateAddress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateAddress(_a0 *ec2.DisassociateAddressInput) (*ec2.DisassociateAddressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateAddressOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateAddressInput) *ec2.DisassociateAddressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateAddressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateAddressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateAddressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateAddressRequest(_a0 *ec2.DisassociateAddressInput) (*request.Request, *ec2.DisassociateAddressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateAddressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateAddressOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateAddressInput) *ec2.DisassociateAddressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateAddressOutput)
		}
	}

	return r0, r1
}

// DisassociateAddressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateAddressWithContext(_a0 context.Context, _a1 *ec2.DisassociateAddressInput, _a2 ...request.Option) (*ec2.DisassociateAddressOutput, 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 *ec2.DisassociateAddressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateAddressInput, ...request.Option) *ec2.DisassociateAddressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateAddressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateAddressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateClientVpnTargetNetwork provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateClientVpnTargetNetwork(_a0 *ec2.DisassociateClientVpnTargetNetworkInput) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateClientVpnTargetNetworkInput) *ec2.DisassociateClientVpnTargetNetworkOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateClientVpnTargetNetworkOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateClientVpnTargetNetworkInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateClientVpnTargetNetworkRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateClientVpnTargetNetworkRequest(_a0 *ec2.DisassociateClientVpnTargetNetworkInput) (*request.Request, *ec2.DisassociateClientVpnTargetNetworkOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateClientVpnTargetNetworkInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateClientVpnTargetNetworkInput) *ec2.DisassociateClientVpnTargetNetworkOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateClientVpnTargetNetworkOutput)
		}
	}

	return r0, r1
}

// DisassociateClientVpnTargetNetworkWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateClientVpnTargetNetworkWithContext(_a0 context.Context, _a1 *ec2.DisassociateClientVpnTargetNetworkInput, _a2 ...request.Option) (*ec2.DisassociateClientVpnTargetNetworkOutput, 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 *ec2.DisassociateClientVpnTargetNetworkOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateClientVpnTargetNetworkInput, ...request.Option) *ec2.DisassociateClientVpnTargetNetworkOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateClientVpnTargetNetworkOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateClientVpnTargetNetworkInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateEnclaveCertificateIamRole provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateEnclaveCertificateIamRole(_a0 *ec2.DisassociateEnclaveCertificateIamRoleInput) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateEnclaveCertificateIamRoleOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateEnclaveCertificateIamRoleInput) *ec2.DisassociateEnclaveCertificateIamRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateEnclaveCertificateIamRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateEnclaveCertificateIamRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateEnclaveCertificateIamRoleRequest(_a0 *ec2.DisassociateEnclaveCertificateIamRoleInput) (*request.Request, *ec2.DisassociateEnclaveCertificateIamRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateEnclaveCertificateIamRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateEnclaveCertificateIamRoleOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateEnclaveCertificateIamRoleInput) *ec2.DisassociateEnclaveCertificateIamRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
		}
	}

	return r0, r1
}

// DisassociateEnclaveCertificateIamRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateEnclaveCertificateIamRoleWithContext(_a0 context.Context, _a1 *ec2.DisassociateEnclaveCertificateIamRoleInput, _a2 ...request.Option) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, 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 *ec2.DisassociateEnclaveCertificateIamRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateEnclaveCertificateIamRoleInput, ...request.Option) *ec2.DisassociateEnclaveCertificateIamRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateEnclaveCertificateIamRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateIamInstanceProfile provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateIamInstanceProfile(_a0 *ec2.DisassociateIamInstanceProfileInput) (*ec2.DisassociateIamInstanceProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateIamInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateIamInstanceProfileInput) *ec2.DisassociateIamInstanceProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateIamInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateIamInstanceProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateIamInstanceProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateIamInstanceProfileRequest(_a0 *ec2.DisassociateIamInstanceProfileInput) (*request.Request, *ec2.DisassociateIamInstanceProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateIamInstanceProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateIamInstanceProfileOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateIamInstanceProfileInput) *ec2.DisassociateIamInstanceProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateIamInstanceProfileOutput)
		}
	}

	return r0, r1
}

// DisassociateIamInstanceProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateIamInstanceProfileWithContext(_a0 context.Context, _a1 *ec2.DisassociateIamInstanceProfileInput, _a2 ...request.Option) (*ec2.DisassociateIamInstanceProfileOutput, 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 *ec2.DisassociateIamInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateIamInstanceProfileInput, ...request.Option) *ec2.DisassociateIamInstanceProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateIamInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateIamInstanceProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateRouteTable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateRouteTable(_a0 *ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateRouteTableOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateRouteTableInput) *ec2.DisassociateRouteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateRouteTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateRouteTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateRouteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateRouteTableRequest(_a0 *ec2.DisassociateRouteTableInput) (*request.Request, *ec2.DisassociateRouteTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateRouteTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateRouteTableOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateRouteTableInput) *ec2.DisassociateRouteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateRouteTableOutput)
		}
	}

	return r0, r1
}

// DisassociateRouteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateRouteTableWithContext(_a0 context.Context, _a1 *ec2.DisassociateRouteTableInput, _a2 ...request.Option) (*ec2.DisassociateRouteTableOutput, 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 *ec2.DisassociateRouteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateRouteTableInput, ...request.Option) *ec2.DisassociateRouteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateRouteTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateRouteTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateSubnetCidrBlock provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateSubnetCidrBlock(_a0 *ec2.DisassociateSubnetCidrBlockInput) (*ec2.DisassociateSubnetCidrBlockOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateSubnetCidrBlockOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateSubnetCidrBlockInput) *ec2.DisassociateSubnetCidrBlockOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateSubnetCidrBlockOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateSubnetCidrBlockInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateSubnetCidrBlockRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateSubnetCidrBlockRequest(_a0 *ec2.DisassociateSubnetCidrBlockInput) (*request.Request, *ec2.DisassociateSubnetCidrBlockOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateSubnetCidrBlockInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateSubnetCidrBlockOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateSubnetCidrBlockInput) *ec2.DisassociateSubnetCidrBlockOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateSubnetCidrBlockOutput)
		}
	}

	return r0, r1
}

// DisassociateSubnetCidrBlockWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateSubnetCidrBlockWithContext(_a0 context.Context, _a1 *ec2.DisassociateSubnetCidrBlockInput, _a2 ...request.Option) (*ec2.DisassociateSubnetCidrBlockOutput, 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 *ec2.DisassociateSubnetCidrBlockOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateSubnetCidrBlockInput, ...request.Option) *ec2.DisassociateSubnetCidrBlockOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateSubnetCidrBlockOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateSubnetCidrBlockInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateTransitGatewayMulticastDomain provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateTransitGatewayMulticastDomain(_a0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateTransitGatewayMulticastDomainInput) *ec2.DisassociateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateTransitGatewayMulticastDomainInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateTransitGatewayMulticastDomainRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateTransitGatewayMulticastDomainRequest(_a0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DisassociateTransitGatewayMulticastDomainOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateTransitGatewayMulticastDomainInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateTransitGatewayMulticastDomainInput) *ec2.DisassociateTransitGatewayMulticastDomainOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
		}
	}

	return r0, r1
}

// DisassociateTransitGatewayMulticastDomainWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateTransitGatewayMulticastDomainWithContext(_a0 context.Context, _a1 *ec2.DisassociateTransitGatewayMulticastDomainInput, _a2 ...request.Option) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, 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 *ec2.DisassociateTransitGatewayMulticastDomainOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTransitGatewayMulticastDomainInput, ...request.Option) *ec2.DisassociateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateTransitGatewayMulticastDomainInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateTransitGatewayRouteTable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateTransitGatewayRouteTable(_a0 *ec2.DisassociateTransitGatewayRouteTableInput) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateTransitGatewayRouteTableInput) *ec2.DisassociateTransitGatewayRouteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTransitGatewayRouteTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateTransitGatewayRouteTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateTransitGatewayRouteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateTransitGatewayRouteTableRequest(_a0 *ec2.DisassociateTransitGatewayRouteTableInput) (*request.Request, *ec2.DisassociateTransitGatewayRouteTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateTransitGatewayRouteTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateTransitGatewayRouteTableInput) *ec2.DisassociateTransitGatewayRouteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateTransitGatewayRouteTableOutput)
		}
	}

	return r0, r1
}

// DisassociateTransitGatewayRouteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateTransitGatewayRouteTableWithContext(_a0 context.Context, _a1 *ec2.DisassociateTransitGatewayRouteTableInput, _a2 ...request.Option) (*ec2.DisassociateTransitGatewayRouteTableOutput, 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 *ec2.DisassociateTransitGatewayRouteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTransitGatewayRouteTableInput, ...request.Option) *ec2.DisassociateTransitGatewayRouteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTransitGatewayRouteTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateTransitGatewayRouteTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateTrunkInterface provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateTrunkInterface(_a0 *ec2.DisassociateTrunkInterfaceInput) (*ec2.DisassociateTrunkInterfaceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateTrunkInterfaceOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateTrunkInterfaceInput) *ec2.DisassociateTrunkInterfaceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTrunkInterfaceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateTrunkInterfaceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateTrunkInterfaceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateTrunkInterfaceRequest(_a0 *ec2.DisassociateTrunkInterfaceInput) (*request.Request, *ec2.DisassociateTrunkInterfaceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateTrunkInterfaceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateTrunkInterfaceOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateTrunkInterfaceInput) *ec2.DisassociateTrunkInterfaceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateTrunkInterfaceOutput)
		}
	}

	return r0, r1
}

// DisassociateTrunkInterfaceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateTrunkInterfaceWithContext(_a0 context.Context, _a1 *ec2.DisassociateTrunkInterfaceInput, _a2 ...request.Option) (*ec2.DisassociateTrunkInterfaceOutput, 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 *ec2.DisassociateTrunkInterfaceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTrunkInterfaceInput, ...request.Option) *ec2.DisassociateTrunkInterfaceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTrunkInterfaceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateTrunkInterfaceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateVpcCidrBlock provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateVpcCidrBlock(_a0 *ec2.DisassociateVpcCidrBlockInput) (*ec2.DisassociateVpcCidrBlockOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.DisassociateVpcCidrBlockOutput
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateVpcCidrBlockInput) *ec2.DisassociateVpcCidrBlockOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateVpcCidrBlockOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateVpcCidrBlockInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateVpcCidrBlockRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) DisassociateVpcCidrBlockRequest(_a0 *ec2.DisassociateVpcCidrBlockInput) (*request.Request, *ec2.DisassociateVpcCidrBlockOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.DisassociateVpcCidrBlockInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.DisassociateVpcCidrBlockOutput
	if rf, ok := ret.Get(1).(func(*ec2.DisassociateVpcCidrBlockInput) *ec2.DisassociateVpcCidrBlockOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.DisassociateVpcCidrBlockOutput)
		}
	}

	return r0, r1
}

// DisassociateVpcCidrBlockWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) DisassociateVpcCidrBlockWithContext(_a0 context.Context, _a1 *ec2.DisassociateVpcCidrBlockInput, _a2 ...request.Option) (*ec2.DisassociateVpcCidrBlockOutput, 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 *ec2.DisassociateVpcCidrBlockOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateVpcCidrBlockInput, ...request.Option) *ec2.DisassociateVpcCidrBlockOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateVpcCidrBlockOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateVpcCidrBlockInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableEbsEncryptionByDefault provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableEbsEncryptionByDefault(_a0 *ec2.EnableEbsEncryptionByDefaultInput) (*ec2.EnableEbsEncryptionByDefaultOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableEbsEncryptionByDefaultInput) *ec2.EnableEbsEncryptionByDefaultOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableEbsEncryptionByDefaultOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableEbsEncryptionByDefaultInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableEbsEncryptionByDefaultRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableEbsEncryptionByDefaultRequest(_a0 *ec2.EnableEbsEncryptionByDefaultInput) (*request.Request, *ec2.EnableEbsEncryptionByDefaultOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableEbsEncryptionByDefaultInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableEbsEncryptionByDefaultInput) *ec2.EnableEbsEncryptionByDefaultOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableEbsEncryptionByDefaultOutput)
		}
	}

	return r0, r1
}

// EnableEbsEncryptionByDefaultWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableEbsEncryptionByDefaultWithContext(_a0 context.Context, _a1 *ec2.EnableEbsEncryptionByDefaultInput, _a2 ...request.Option) (*ec2.EnableEbsEncryptionByDefaultOutput, 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 *ec2.EnableEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableEbsEncryptionByDefaultInput, ...request.Option) *ec2.EnableEbsEncryptionByDefaultOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableEbsEncryptionByDefaultOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableEbsEncryptionByDefaultInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableFastSnapshotRestores provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableFastSnapshotRestores(_a0 *ec2.EnableFastSnapshotRestoresInput) (*ec2.EnableFastSnapshotRestoresOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableFastSnapshotRestoresOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableFastSnapshotRestoresInput) *ec2.EnableFastSnapshotRestoresOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableFastSnapshotRestoresOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableFastSnapshotRestoresInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableFastSnapshotRestoresRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableFastSnapshotRestoresRequest(_a0 *ec2.EnableFastSnapshotRestoresInput) (*request.Request, *ec2.EnableFastSnapshotRestoresOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableFastSnapshotRestoresInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableFastSnapshotRestoresOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableFastSnapshotRestoresInput) *ec2.EnableFastSnapshotRestoresOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableFastSnapshotRestoresOutput)
		}
	}

	return r0, r1
}

// EnableFastSnapshotRestoresWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableFastSnapshotRestoresWithContext(_a0 context.Context, _a1 *ec2.EnableFastSnapshotRestoresInput, _a2 ...request.Option) (*ec2.EnableFastSnapshotRestoresOutput, 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 *ec2.EnableFastSnapshotRestoresOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableFastSnapshotRestoresInput, ...request.Option) *ec2.EnableFastSnapshotRestoresOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableFastSnapshotRestoresOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableFastSnapshotRestoresInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableImageDeprecation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableImageDeprecation(_a0 *ec2.EnableImageDeprecationInput) (*ec2.EnableImageDeprecationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableImageDeprecationOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableImageDeprecationInput) *ec2.EnableImageDeprecationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableImageDeprecationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableImageDeprecationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableImageDeprecationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableImageDeprecationRequest(_a0 *ec2.EnableImageDeprecationInput) (*request.Request, *ec2.EnableImageDeprecationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableImageDeprecationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableImageDeprecationOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableImageDeprecationInput) *ec2.EnableImageDeprecationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableImageDeprecationOutput)
		}
	}

	return r0, r1
}

// EnableImageDeprecationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableImageDeprecationWithContext(_a0 context.Context, _a1 *ec2.EnableImageDeprecationInput, _a2 ...request.Option) (*ec2.EnableImageDeprecationOutput, 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 *ec2.EnableImageDeprecationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageDeprecationInput, ...request.Option) *ec2.EnableImageDeprecationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableImageDeprecationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableImageDeprecationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableSerialConsoleAccess provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableSerialConsoleAccess(_a0 *ec2.EnableSerialConsoleAccessInput) (*ec2.EnableSerialConsoleAccessOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableSerialConsoleAccessOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableSerialConsoleAccessInput) *ec2.EnableSerialConsoleAccessOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableSerialConsoleAccessOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableSerialConsoleAccessInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableSerialConsoleAccessRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableSerialConsoleAccessRequest(_a0 *ec2.EnableSerialConsoleAccessInput) (*request.Request, *ec2.EnableSerialConsoleAccessOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableSerialConsoleAccessInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableSerialConsoleAccessOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableSerialConsoleAccessInput) *ec2.EnableSerialConsoleAccessOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableSerialConsoleAccessOutput)
		}
	}

	return r0, r1
}

// EnableSerialConsoleAccessWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableSerialConsoleAccessWithContext(_a0 context.Context, _a1 *ec2.EnableSerialConsoleAccessInput, _a2 ...request.Option) (*ec2.EnableSerialConsoleAccessOutput, 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 *ec2.EnableSerialConsoleAccessOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableSerialConsoleAccessInput, ...request.Option) *ec2.EnableSerialConsoleAccessOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableSerialConsoleAccessOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableSerialConsoleAccessInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableTransitGatewayRouteTablePropagation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableTransitGatewayRouteTablePropagation(_a0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableTransitGatewayRouteTablePropagationOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableTransitGatewayRouteTablePropagationInput) *ec2.EnableTransitGatewayRouteTablePropagationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableTransitGatewayRouteTablePropagationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableTransitGatewayRouteTablePropagationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableTransitGatewayRouteTablePropagationRequest(_a0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.EnableTransitGatewayRouteTablePropagationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableTransitGatewayRouteTablePropagationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableTransitGatewayRouteTablePropagationOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableTransitGatewayRouteTablePropagationInput) *ec2.EnableTransitGatewayRouteTablePropagationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
		}
	}

	return r0, r1
}

// EnableTransitGatewayRouteTablePropagationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableTransitGatewayRouteTablePropagationWithContext(_a0 context.Context, _a1 *ec2.EnableTransitGatewayRouteTablePropagationInput, _a2 ...request.Option) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, 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 *ec2.EnableTransitGatewayRouteTablePropagationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableTransitGatewayRouteTablePropagationInput, ...request.Option) *ec2.EnableTransitGatewayRouteTablePropagationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableTransitGatewayRouteTablePropagationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableVgwRoutePropagation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableVgwRoutePropagation(_a0 *ec2.EnableVgwRoutePropagationInput) (*ec2.EnableVgwRoutePropagationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableVgwRoutePropagationOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableVgwRoutePropagationInput) *ec2.EnableVgwRoutePropagationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVgwRoutePropagationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableVgwRoutePropagationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableVgwRoutePropagationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableVgwRoutePropagationRequest(_a0 *ec2.EnableVgwRoutePropagationInput) (*request.Request, *ec2.EnableVgwRoutePropagationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableVgwRoutePropagationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableVgwRoutePropagationOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableVgwRoutePropagationInput) *ec2.EnableVgwRoutePropagationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableVgwRoutePropagationOutput)
		}
	}

	return r0, r1
}

// EnableVgwRoutePropagationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableVgwRoutePropagationWithContext(_a0 context.Context, _a1 *ec2.EnableVgwRoutePropagationInput, _a2 ...request.Option) (*ec2.EnableVgwRoutePropagationOutput, 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 *ec2.EnableVgwRoutePropagationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVgwRoutePropagationInput, ...request.Option) *ec2.EnableVgwRoutePropagationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVgwRoutePropagationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableVgwRoutePropagationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableVolumeIO provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableVolumeIO(_a0 *ec2.EnableVolumeIOInput) (*ec2.EnableVolumeIOOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableVolumeIOOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableVolumeIOInput) *ec2.EnableVolumeIOOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVolumeIOOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableVolumeIOInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableVolumeIORequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableVolumeIORequest(_a0 *ec2.EnableVolumeIOInput) (*request.Request, *ec2.EnableVolumeIOOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableVolumeIOInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableVolumeIOOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableVolumeIOInput) *ec2.EnableVolumeIOOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableVolumeIOOutput)
		}
	}

	return r0, r1
}

// EnableVolumeIOWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableVolumeIOWithContext(_a0 context.Context, _a1 *ec2.EnableVolumeIOInput, _a2 ...request.Option) (*ec2.EnableVolumeIOOutput, 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 *ec2.EnableVolumeIOOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVolumeIOInput, ...request.Option) *ec2.EnableVolumeIOOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVolumeIOOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableVolumeIOInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableVpcClassicLink provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableVpcClassicLink(_a0 *ec2.EnableVpcClassicLinkInput) (*ec2.EnableVpcClassicLinkOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableVpcClassicLinkOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableVpcClassicLinkInput) *ec2.EnableVpcClassicLinkOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVpcClassicLinkOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableVpcClassicLinkInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableVpcClassicLinkDnsSupport provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableVpcClassicLinkDnsSupport(_a0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.EnableVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(0).(func(*ec2.EnableVpcClassicLinkDnsSupportInput) *ec2.EnableVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVpcClassicLinkDnsSupportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.EnableVpcClassicLinkDnsSupportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableVpcClassicLinkDnsSupportRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableVpcClassicLinkDnsSupportRequest(_a0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.EnableVpcClassicLinkDnsSupportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableVpcClassicLinkDnsSupportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableVpcClassicLinkDnsSupportInput) *ec2.EnableVpcClassicLinkDnsSupportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableVpcClassicLinkDnsSupportOutput)
		}
	}

	return r0, r1
}

// EnableVpcClassicLinkDnsSupportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableVpcClassicLinkDnsSupportWithContext(_a0 context.Context, _a1 *ec2.EnableVpcClassicLinkDnsSupportInput, _a2 ...request.Option) (*ec2.EnableVpcClassicLinkDnsSupportOutput, 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 *ec2.EnableVpcClassicLinkDnsSupportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVpcClassicLinkDnsSupportInput, ...request.Option) *ec2.EnableVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVpcClassicLinkDnsSupportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableVpcClassicLinkDnsSupportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableVpcClassicLinkRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) EnableVpcClassicLinkRequest(_a0 *ec2.EnableVpcClassicLinkInput) (*request.Request, *ec2.EnableVpcClassicLinkOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.EnableVpcClassicLinkInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.EnableVpcClassicLinkOutput
	if rf, ok := ret.Get(1).(func(*ec2.EnableVpcClassicLinkInput) *ec2.EnableVpcClassicLinkOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.EnableVpcClassicLinkOutput)
		}
	}

	return r0, r1
}

// EnableVpcClassicLinkWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) EnableVpcClassicLinkWithContext(_a0 context.Context, _a1 *ec2.EnableVpcClassicLinkInput, _a2 ...request.Option) (*ec2.EnableVpcClassicLinkOutput, 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 *ec2.EnableVpcClassicLinkOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVpcClassicLinkInput, ...request.Option) *ec2.EnableVpcClassicLinkOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVpcClassicLinkOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableVpcClassicLinkInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportClientVpnClientCertificateRevocationList provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ExportClientVpnClientCertificateRevocationList(_a0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ExportClientVpnClientCertificateRevocationListOutput
	if rf, ok := ret.Get(0).(func(*ec2.ExportClientVpnClientCertificateRevocationListInput) *ec2.ExportClientVpnClientCertificateRevocationListOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ExportClientVpnClientCertificateRevocationListInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportClientVpnClientCertificateRevocationListRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ExportClientVpnClientCertificateRevocationListRequest(_a0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ExportClientVpnClientCertificateRevocationListOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ExportClientVpnClientCertificateRevocationListInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ExportClientVpnClientCertificateRevocationListOutput
	if rf, ok := ret.Get(1).(func(*ec2.ExportClientVpnClientCertificateRevocationListInput) *ec2.ExportClientVpnClientCertificateRevocationListOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
		}
	}

	return r0, r1
}

// ExportClientVpnClientCertificateRevocationListWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ExportClientVpnClientCertificateRevocationListWithContext(_a0 context.Context, _a1 *ec2.ExportClientVpnClientCertificateRevocationListInput, _a2 ...request.Option) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, 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 *ec2.ExportClientVpnClientCertificateRevocationListOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportClientVpnClientCertificateRevocationListInput, ...request.Option) *ec2.ExportClientVpnClientCertificateRevocationListOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportClientVpnClientCertificateRevocationListInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportClientVpnClientConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ExportClientVpnClientConfiguration(_a0 *ec2.ExportClientVpnClientConfigurationInput) (*ec2.ExportClientVpnClientConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ExportClientVpnClientConfigurationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ExportClientVpnClientConfigurationInput) *ec2.ExportClientVpnClientConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportClientVpnClientConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ExportClientVpnClientConfigurationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportClientVpnClientConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ExportClientVpnClientConfigurationRequest(_a0 *ec2.ExportClientVpnClientConfigurationInput) (*request.Request, *ec2.ExportClientVpnClientConfigurationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ExportClientVpnClientConfigurationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ExportClientVpnClientConfigurationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ExportClientVpnClientConfigurationInput) *ec2.ExportClientVpnClientConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ExportClientVpnClientConfigurationOutput)
		}
	}

	return r0, r1
}

// ExportClientVpnClientConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ExportClientVpnClientConfigurationWithContext(_a0 context.Context, _a1 *ec2.ExportClientVpnClientConfigurationInput, _a2 ...request.Option) (*ec2.ExportClientVpnClientConfigurationOutput, 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 *ec2.ExportClientVpnClientConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportClientVpnClientConfigurationInput, ...request.Option) *ec2.ExportClientVpnClientConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportClientVpnClientConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportClientVpnClientConfigurationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ExportImage(_a0 *ec2.ExportImageInput) (*ec2.ExportImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ExportImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.ExportImageInput) *ec2.ExportImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ExportImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ExportImageRequest(_a0 *ec2.ExportImageInput) (*request.Request, *ec2.ExportImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ExportImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ExportImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.ExportImageInput) *ec2.ExportImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ExportImageOutput)
		}
	}

	return r0, r1
}

// ExportImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ExportImageWithContext(_a0 context.Context, _a1 *ec2.ExportImageInput, _a2 ...request.Option) (*ec2.ExportImageOutput, 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 *ec2.ExportImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportImageInput, ...request.Option) *ec2.ExportImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportTransitGatewayRoutes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ExportTransitGatewayRoutes(_a0 *ec2.ExportTransitGatewayRoutesInput) (*ec2.ExportTransitGatewayRoutesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ExportTransitGatewayRoutesOutput
	if rf, ok := ret.Get(0).(func(*ec2.ExportTransitGatewayRoutesInput) *ec2.ExportTransitGatewayRoutesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportTransitGatewayRoutesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ExportTransitGatewayRoutesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportTransitGatewayRoutesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ExportTransitGatewayRoutesRequest(_a0 *ec2.ExportTransitGatewayRoutesInput) (*request.Request, *ec2.ExportTransitGatewayRoutesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ExportTransitGatewayRoutesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ExportTransitGatewayRoutesOutput
	if rf, ok := ret.Get(1).(func(*ec2.ExportTransitGatewayRoutesInput) *ec2.ExportTransitGatewayRoutesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ExportTransitGatewayRoutesOutput)
		}
	}

	return r0, r1
}

// ExportTransitGatewayRoutesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ExportTransitGatewayRoutesWithContext(_a0 context.Context, _a1 *ec2.ExportTransitGatewayRoutesInput, _a2 ...request.Option) (*ec2.ExportTransitGatewayRoutesOutput, 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 *ec2.ExportTransitGatewayRoutesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportTransitGatewayRoutesInput, ...request.Option) *ec2.ExportTransitGatewayRoutesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportTransitGatewayRoutesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportTransitGatewayRoutesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAssociatedEnclaveCertificateIamRoles provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetAssociatedEnclaveCertificateIamRoles(_a0 *ec2.GetAssociatedEnclaveCertificateIamRolesInput) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetAssociatedEnclaveCertificateIamRolesOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetAssociatedEnclaveCertificateIamRolesInput) *ec2.GetAssociatedEnclaveCertificateIamRolesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetAssociatedEnclaveCertificateIamRolesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAssociatedEnclaveCertificateIamRolesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetAssociatedEnclaveCertificateIamRolesRequest(_a0 *ec2.GetAssociatedEnclaveCertificateIamRolesInput) (*request.Request, *ec2.GetAssociatedEnclaveCertificateIamRolesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetAssociatedEnclaveCertificateIamRolesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetAssociatedEnclaveCertificateIamRolesOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetAssociatedEnclaveCertificateIamRolesInput) *ec2.GetAssociatedEnclaveCertificateIamRolesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
		}
	}

	return r0, r1
}

// GetAssociatedEnclaveCertificateIamRolesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetAssociatedEnclaveCertificateIamRolesWithContext(_a0 context.Context, _a1 *ec2.GetAssociatedEnclaveCertificateIamRolesInput, _a2 ...request.Option) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, 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 *ec2.GetAssociatedEnclaveCertificateIamRolesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAssociatedEnclaveCertificateIamRolesInput, ...request.Option) *ec2.GetAssociatedEnclaveCertificateIamRolesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetAssociatedEnclaveCertificateIamRolesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAssociatedIpv6PoolCidrs provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetAssociatedIpv6PoolCidrs(_a0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetAssociatedIpv6PoolCidrsOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetAssociatedIpv6PoolCidrsInput) *ec2.GetAssociatedIpv6PoolCidrsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetAssociatedIpv6PoolCidrsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetAssociatedIpv6PoolCidrsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAssociatedIpv6PoolCidrsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetAssociatedIpv6PoolCidrsPages(_a0 *ec2.GetAssociatedIpv6PoolCidrsInput, _a1 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetAssociatedIpv6PoolCidrsInput, func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetAssociatedIpv6PoolCidrsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetAssociatedIpv6PoolCidrsPagesWithContext(_a0 context.Context, _a1 *ec2.GetAssociatedIpv6PoolCidrsInput, _a2 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, 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, *ec2.GetAssociatedIpv6PoolCidrsInput, func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetAssociatedIpv6PoolCidrsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetAssociatedIpv6PoolCidrsRequest(_a0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*request.Request, *ec2.GetAssociatedIpv6PoolCidrsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetAssociatedIpv6PoolCidrsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetAssociatedIpv6PoolCidrsOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetAssociatedIpv6PoolCidrsInput) *ec2.GetAssociatedIpv6PoolCidrsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetAssociatedIpv6PoolCidrsOutput)
		}
	}

	return r0, r1
}

// GetAssociatedIpv6PoolCidrsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetAssociatedIpv6PoolCidrsWithContext(_a0 context.Context, _a1 *ec2.GetAssociatedIpv6PoolCidrsInput, _a2 ...request.Option) (*ec2.GetAssociatedIpv6PoolCidrsOutput, 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 *ec2.GetAssociatedIpv6PoolCidrsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAssociatedIpv6PoolCidrsInput, ...request.Option) *ec2.GetAssociatedIpv6PoolCidrsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetAssociatedIpv6PoolCidrsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetAssociatedIpv6PoolCidrsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCapacityReservationUsage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetCapacityReservationUsage(_a0 *ec2.GetCapacityReservationUsageInput) (*ec2.GetCapacityReservationUsageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetCapacityReservationUsageOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetCapacityReservationUsageInput) *ec2.GetCapacityReservationUsageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCapacityReservationUsageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetCapacityReservationUsageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCapacityReservationUsageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetCapacityReservationUsageRequest(_a0 *ec2.GetCapacityReservationUsageInput) (*request.Request, *ec2.GetCapacityReservationUsageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetCapacityReservationUsageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetCapacityReservationUsageOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetCapacityReservationUsageInput) *ec2.GetCapacityReservationUsageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetCapacityReservationUsageOutput)
		}
	}

	return r0, r1
}

// GetCapacityReservationUsageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetCapacityReservationUsageWithContext(_a0 context.Context, _a1 *ec2.GetCapacityReservationUsageInput, _a2 ...request.Option) (*ec2.GetCapacityReservationUsageOutput, 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 *ec2.GetCapacityReservationUsageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityReservationUsageInput, ...request.Option) *ec2.GetCapacityReservationUsageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCapacityReservationUsageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetCapacityReservationUsageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCoipPoolUsage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetCoipPoolUsage(_a0 *ec2.GetCoipPoolUsageInput) (*ec2.GetCoipPoolUsageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetCoipPoolUsageOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetCoipPoolUsageInput) *ec2.GetCoipPoolUsageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCoipPoolUsageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetCoipPoolUsageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCoipPoolUsageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetCoipPoolUsageRequest(_a0 *ec2.GetCoipPoolUsageInput) (*request.Request, *ec2.GetCoipPoolUsageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetCoipPoolUsageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetCoipPoolUsageOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetCoipPoolUsageInput) *ec2.GetCoipPoolUsageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetCoipPoolUsageOutput)
		}
	}

	return r0, r1
}

// GetCoipPoolUsageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetCoipPoolUsageWithContext(_a0 context.Context, _a1 *ec2.GetCoipPoolUsageInput, _a2 ...request.Option) (*ec2.GetCoipPoolUsageOutput, 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 *ec2.GetCoipPoolUsageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCoipPoolUsageInput, ...request.Option) *ec2.GetCoipPoolUsageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCoipPoolUsageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetCoipPoolUsageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetConsoleOutput provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetConsoleOutput(_a0 *ec2.GetConsoleOutputInput) (*ec2.GetConsoleOutputOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetConsoleOutputOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetConsoleOutputInput) *ec2.GetConsoleOutputOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetConsoleOutputOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetConsoleOutputInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetConsoleOutputRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetConsoleOutputRequest(_a0 *ec2.GetConsoleOutputInput) (*request.Request, *ec2.GetConsoleOutputOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetConsoleOutputInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetConsoleOutputOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetConsoleOutputInput) *ec2.GetConsoleOutputOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetConsoleOutputOutput)
		}
	}

	return r0, r1
}

// GetConsoleOutputWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetConsoleOutputWithContext(_a0 context.Context, _a1 *ec2.GetConsoleOutputInput, _a2 ...request.Option) (*ec2.GetConsoleOutputOutput, 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 *ec2.GetConsoleOutputOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetConsoleOutputInput, ...request.Option) *ec2.GetConsoleOutputOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetConsoleOutputOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetConsoleOutputInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetConsoleScreenshot provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetConsoleScreenshot(_a0 *ec2.GetConsoleScreenshotInput) (*ec2.GetConsoleScreenshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetConsoleScreenshotOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetConsoleScreenshotInput) *ec2.GetConsoleScreenshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetConsoleScreenshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetConsoleScreenshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetConsoleScreenshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetConsoleScreenshotRequest(_a0 *ec2.GetConsoleScreenshotInput) (*request.Request, *ec2.GetConsoleScreenshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetConsoleScreenshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetConsoleScreenshotOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetConsoleScreenshotInput) *ec2.GetConsoleScreenshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetConsoleScreenshotOutput)
		}
	}

	return r0, r1
}

// GetConsoleScreenshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetConsoleScreenshotWithContext(_a0 context.Context, _a1 *ec2.GetConsoleScreenshotInput, _a2 ...request.Option) (*ec2.GetConsoleScreenshotOutput, 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 *ec2.GetConsoleScreenshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetConsoleScreenshotInput, ...request.Option) *ec2.GetConsoleScreenshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetConsoleScreenshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetConsoleScreenshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetDefaultCreditSpecification provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetDefaultCreditSpecification(_a0 *ec2.GetDefaultCreditSpecificationInput) (*ec2.GetDefaultCreditSpecificationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetDefaultCreditSpecificationOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetDefaultCreditSpecificationInput) *ec2.GetDefaultCreditSpecificationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetDefaultCreditSpecificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetDefaultCreditSpecificationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetDefaultCreditSpecificationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetDefaultCreditSpecificationRequest(_a0 *ec2.GetDefaultCreditSpecificationInput) (*request.Request, *ec2.GetDefaultCreditSpecificationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetDefaultCreditSpecificationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetDefaultCreditSpecificationOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetDefaultCreditSpecificationInput) *ec2.GetDefaultCreditSpecificationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetDefaultCreditSpecificationOutput)
		}
	}

	return r0, r1
}

// GetDefaultCreditSpecificationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetDefaultCreditSpecificationWithContext(_a0 context.Context, _a1 *ec2.GetDefaultCreditSpecificationInput, _a2 ...request.Option) (*ec2.GetDefaultCreditSpecificationOutput, 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 *ec2.GetDefaultCreditSpecificationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetDefaultCreditSpecificationInput, ...request.Option) *ec2.GetDefaultCreditSpecificationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetDefaultCreditSpecificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetDefaultCreditSpecificationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEbsDefaultKmsKeyId provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetEbsDefaultKmsKeyId(_a0 *ec2.GetEbsDefaultKmsKeyIdInput) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetEbsDefaultKmsKeyIdInput) *ec2.GetEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetEbsDefaultKmsKeyIdOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetEbsDefaultKmsKeyIdInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEbsDefaultKmsKeyIdRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetEbsDefaultKmsKeyIdRequest(_a0 *ec2.GetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.GetEbsDefaultKmsKeyIdOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetEbsDefaultKmsKeyIdInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetEbsDefaultKmsKeyIdInput) *ec2.GetEbsDefaultKmsKeyIdOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetEbsDefaultKmsKeyIdOutput)
		}
	}

	return r0, r1
}

// GetEbsDefaultKmsKeyIdWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetEbsDefaultKmsKeyIdWithContext(_a0 context.Context, _a1 *ec2.GetEbsDefaultKmsKeyIdInput, _a2 ...request.Option) (*ec2.GetEbsDefaultKmsKeyIdOutput, 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 *ec2.GetEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEbsDefaultKmsKeyIdInput, ...request.Option) *ec2.GetEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetEbsDefaultKmsKeyIdOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetEbsDefaultKmsKeyIdInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEbsEncryptionByDefault provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetEbsEncryptionByDefault(_a0 *ec2.GetEbsEncryptionByDefaultInput) (*ec2.GetEbsEncryptionByDefaultOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetEbsEncryptionByDefaultInput) *ec2.GetEbsEncryptionByDefaultOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetEbsEncryptionByDefaultOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetEbsEncryptionByDefaultInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEbsEncryptionByDefaultRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetEbsEncryptionByDefaultRequest(_a0 *ec2.GetEbsEncryptionByDefaultInput) (*request.Request, *ec2.GetEbsEncryptionByDefaultOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetEbsEncryptionByDefaultInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetEbsEncryptionByDefaultInput) *ec2.GetEbsEncryptionByDefaultOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetEbsEncryptionByDefaultOutput)
		}
	}

	return r0, r1
}

// GetEbsEncryptionByDefaultWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetEbsEncryptionByDefaultWithContext(_a0 context.Context, _a1 *ec2.GetEbsEncryptionByDefaultInput, _a2 ...request.Option) (*ec2.GetEbsEncryptionByDefaultOutput, 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 *ec2.GetEbsEncryptionByDefaultOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEbsEncryptionByDefaultInput, ...request.Option) *ec2.GetEbsEncryptionByDefaultOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetEbsEncryptionByDefaultOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetEbsEncryptionByDefaultInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFlowLogsIntegrationTemplate provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetFlowLogsIntegrationTemplate(_a0 *ec2.GetFlowLogsIntegrationTemplateInput) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetFlowLogsIntegrationTemplateOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetFlowLogsIntegrationTemplateInput) *ec2.GetFlowLogsIntegrationTemplateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetFlowLogsIntegrationTemplateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetFlowLogsIntegrationTemplateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetFlowLogsIntegrationTemplateRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetFlowLogsIntegrationTemplateRequest(_a0 *ec2.GetFlowLogsIntegrationTemplateInput) (*request.Request, *ec2.GetFlowLogsIntegrationTemplateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetFlowLogsIntegrationTemplateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetFlowLogsIntegrationTemplateOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetFlowLogsIntegrationTemplateInput) *ec2.GetFlowLogsIntegrationTemplateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetFlowLogsIntegrationTemplateOutput)
		}
	}

	return r0, r1
}

// GetFlowLogsIntegrationTemplateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetFlowLogsIntegrationTemplateWithContext(_a0 context.Context, _a1 *ec2.GetFlowLogsIntegrationTemplateInput, _a2 ...request.Option) (*ec2.GetFlowLogsIntegrationTemplateOutput, 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 *ec2.GetFlowLogsIntegrationTemplateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetFlowLogsIntegrationTemplateInput, ...request.Option) *ec2.GetFlowLogsIntegrationTemplateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetFlowLogsIntegrationTemplateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetFlowLogsIntegrationTemplateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetGroupsForCapacityReservation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetGroupsForCapacityReservation(_a0 *ec2.GetGroupsForCapacityReservationInput) (*ec2.GetGroupsForCapacityReservationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetGroupsForCapacityReservationOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetGroupsForCapacityReservationInput) *ec2.GetGroupsForCapacityReservationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetGroupsForCapacityReservationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetGroupsForCapacityReservationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetGroupsForCapacityReservationPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetGroupsForCapacityReservationPages(_a0 *ec2.GetGroupsForCapacityReservationInput, _a1 func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetGroupsForCapacityReservationInput, func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetGroupsForCapacityReservationPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetGroupsForCapacityReservationPagesWithContext(_a0 context.Context, _a1 *ec2.GetGroupsForCapacityReservationInput, _a2 func(*ec2.GetGroupsForCapacityReservationOutput, 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, *ec2.GetGroupsForCapacityReservationInput, func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetGroupsForCapacityReservationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetGroupsForCapacityReservationRequest(_a0 *ec2.GetGroupsForCapacityReservationInput) (*request.Request, *ec2.GetGroupsForCapacityReservationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetGroupsForCapacityReservationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetGroupsForCapacityReservationOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetGroupsForCapacityReservationInput) *ec2.GetGroupsForCapacityReservationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetGroupsForCapacityReservationOutput)
		}
	}

	return r0, r1
}

// GetGroupsForCapacityReservationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetGroupsForCapacityReservationWithContext(_a0 context.Context, _a1 *ec2.GetGroupsForCapacityReservationInput, _a2 ...request.Option) (*ec2.GetGroupsForCapacityReservationOutput, 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 *ec2.GetGroupsForCapacityReservationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetGroupsForCapacityReservationInput, ...request.Option) *ec2.GetGroupsForCapacityReservationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetGroupsForCapacityReservationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetGroupsForCapacityReservationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostReservationPurchasePreview provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetHostReservationPurchasePreview(_a0 *ec2.GetHostReservationPurchasePreviewInput) (*ec2.GetHostReservationPurchasePreviewOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetHostReservationPurchasePreviewOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetHostReservationPurchasePreviewInput) *ec2.GetHostReservationPurchasePreviewOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetHostReservationPurchasePreviewOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetHostReservationPurchasePreviewInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostReservationPurchasePreviewRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetHostReservationPurchasePreviewRequest(_a0 *ec2.GetHostReservationPurchasePreviewInput) (*request.Request, *ec2.GetHostReservationPurchasePreviewOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetHostReservationPurchasePreviewInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetHostReservationPurchasePreviewOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetHostReservationPurchasePreviewInput) *ec2.GetHostReservationPurchasePreviewOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetHostReservationPurchasePreviewOutput)
		}
	}

	return r0, r1
}

// GetHostReservationPurchasePreviewWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetHostReservationPurchasePreviewWithContext(_a0 context.Context, _a1 *ec2.GetHostReservationPurchasePreviewInput, _a2 ...request.Option) (*ec2.GetHostReservationPurchasePreviewOutput, 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 *ec2.GetHostReservationPurchasePreviewOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetHostReservationPurchasePreviewInput, ...request.Option) *ec2.GetHostReservationPurchasePreviewOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetHostReservationPurchasePreviewOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetHostReservationPurchasePreviewInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLaunchTemplateData provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetLaunchTemplateData(_a0 *ec2.GetLaunchTemplateDataInput) (*ec2.GetLaunchTemplateDataOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetLaunchTemplateDataOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetLaunchTemplateDataInput) *ec2.GetLaunchTemplateDataOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetLaunchTemplateDataOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetLaunchTemplateDataInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLaunchTemplateDataRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetLaunchTemplateDataRequest(_a0 *ec2.GetLaunchTemplateDataInput) (*request.Request, *ec2.GetLaunchTemplateDataOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetLaunchTemplateDataInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetLaunchTemplateDataOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetLaunchTemplateDataInput) *ec2.GetLaunchTemplateDataOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetLaunchTemplateDataOutput)
		}
	}

	return r0, r1
}

// GetLaunchTemplateDataWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetLaunchTemplateDataWithContext(_a0 context.Context, _a1 *ec2.GetLaunchTemplateDataInput, _a2 ...request.Option) (*ec2.GetLaunchTemplateDataOutput, 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 *ec2.GetLaunchTemplateDataOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetLaunchTemplateDataInput, ...request.Option) *ec2.GetLaunchTemplateDataOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetLaunchTemplateDataOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetLaunchTemplateDataInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetManagedPrefixListAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetManagedPrefixListAssociations(_a0 *ec2.GetManagedPrefixListAssociationsInput) (*ec2.GetManagedPrefixListAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetManagedPrefixListAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetManagedPrefixListAssociationsInput) *ec2.GetManagedPrefixListAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetManagedPrefixListAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetManagedPrefixListAssociationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetManagedPrefixListAssociationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetManagedPrefixListAssociationsPages(_a0 *ec2.GetManagedPrefixListAssociationsInput, _a1 func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetManagedPrefixListAssociationsInput, func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetManagedPrefixListAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetManagedPrefixListAssociationsPagesWithContext(_a0 context.Context, _a1 *ec2.GetManagedPrefixListAssociationsInput, _a2 func(*ec2.GetManagedPrefixListAssociationsOutput, 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, *ec2.GetManagedPrefixListAssociationsInput, func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetManagedPrefixListAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetManagedPrefixListAssociationsRequest(_a0 *ec2.GetManagedPrefixListAssociationsInput) (*request.Request, *ec2.GetManagedPrefixListAssociationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetManagedPrefixListAssociationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetManagedPrefixListAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetManagedPrefixListAssociationsInput) *ec2.GetManagedPrefixListAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetManagedPrefixListAssociationsOutput)
		}
	}

	return r0, r1
}

// GetManagedPrefixListAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetManagedPrefixListAssociationsWithContext(_a0 context.Context, _a1 *ec2.GetManagedPrefixListAssociationsInput, _a2 ...request.Option) (*ec2.GetManagedPrefixListAssociationsOutput, 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 *ec2.GetManagedPrefixListAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetManagedPrefixListAssociationsInput, ...request.Option) *ec2.GetManagedPrefixListAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetManagedPrefixListAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetManagedPrefixListAssociationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetManagedPrefixListEntries provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetManagedPrefixListEntries(_a0 *ec2.GetManagedPrefixListEntriesInput) (*ec2.GetManagedPrefixListEntriesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetManagedPrefixListEntriesOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetManagedPrefixListEntriesInput) *ec2.GetManagedPrefixListEntriesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetManagedPrefixListEntriesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetManagedPrefixListEntriesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetManagedPrefixListEntriesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetManagedPrefixListEntriesPages(_a0 *ec2.GetManagedPrefixListEntriesInput, _a1 func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetManagedPrefixListEntriesInput, func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetManagedPrefixListEntriesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetManagedPrefixListEntriesPagesWithContext(_a0 context.Context, _a1 *ec2.GetManagedPrefixListEntriesInput, _a2 func(*ec2.GetManagedPrefixListEntriesOutput, 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, *ec2.GetManagedPrefixListEntriesInput, func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetManagedPrefixListEntriesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetManagedPrefixListEntriesRequest(_a0 *ec2.GetManagedPrefixListEntriesInput) (*request.Request, *ec2.GetManagedPrefixListEntriesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetManagedPrefixListEntriesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetManagedPrefixListEntriesOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetManagedPrefixListEntriesInput) *ec2.GetManagedPrefixListEntriesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetManagedPrefixListEntriesOutput)
		}
	}

	return r0, r1
}

// GetManagedPrefixListEntriesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetManagedPrefixListEntriesWithContext(_a0 context.Context, _a1 *ec2.GetManagedPrefixListEntriesInput, _a2 ...request.Option) (*ec2.GetManagedPrefixListEntriesOutput, 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 *ec2.GetManagedPrefixListEntriesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetManagedPrefixListEntriesInput, ...request.Option) *ec2.GetManagedPrefixListEntriesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetManagedPrefixListEntriesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetManagedPrefixListEntriesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPasswordData provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetPasswordData(_a0 *ec2.GetPasswordDataInput) (*ec2.GetPasswordDataOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetPasswordDataOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetPasswordDataInput) *ec2.GetPasswordDataOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetPasswordDataOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetPasswordDataInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPasswordDataRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetPasswordDataRequest(_a0 *ec2.GetPasswordDataInput) (*request.Request, *ec2.GetPasswordDataOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetPasswordDataInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetPasswordDataOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetPasswordDataInput) *ec2.GetPasswordDataOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetPasswordDataOutput)
		}
	}

	return r0, r1
}

// GetPasswordDataWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetPasswordDataWithContext(_a0 context.Context, _a1 *ec2.GetPasswordDataInput, _a2 ...request.Option) (*ec2.GetPasswordDataOutput, 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 *ec2.GetPasswordDataOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetPasswordDataInput, ...request.Option) *ec2.GetPasswordDataOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetPasswordDataOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetPasswordDataInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetReservedInstancesExchangeQuote provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetReservedInstancesExchangeQuote(_a0 *ec2.GetReservedInstancesExchangeQuoteInput) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetReservedInstancesExchangeQuoteOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetReservedInstancesExchangeQuoteInput) *ec2.GetReservedInstancesExchangeQuoteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetReservedInstancesExchangeQuoteOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetReservedInstancesExchangeQuoteInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetReservedInstancesExchangeQuoteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetReservedInstancesExchangeQuoteRequest(_a0 *ec2.GetReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.GetReservedInstancesExchangeQuoteOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetReservedInstancesExchangeQuoteInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetReservedInstancesExchangeQuoteOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetReservedInstancesExchangeQuoteInput) *ec2.GetReservedInstancesExchangeQuoteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetReservedInstancesExchangeQuoteOutput)
		}
	}

	return r0, r1
}

// GetReservedInstancesExchangeQuoteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetReservedInstancesExchangeQuoteWithContext(_a0 context.Context, _a1 *ec2.GetReservedInstancesExchangeQuoteInput, _a2 ...request.Option) (*ec2.GetReservedInstancesExchangeQuoteOutput, 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 *ec2.GetReservedInstancesExchangeQuoteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetReservedInstancesExchangeQuoteInput, ...request.Option) *ec2.GetReservedInstancesExchangeQuoteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetReservedInstancesExchangeQuoteOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetReservedInstancesExchangeQuoteInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSerialConsoleAccessStatus provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetSerialConsoleAccessStatus(_a0 *ec2.GetSerialConsoleAccessStatusInput) (*ec2.GetSerialConsoleAccessStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetSerialConsoleAccessStatusOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetSerialConsoleAccessStatusInput) *ec2.GetSerialConsoleAccessStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetSerialConsoleAccessStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetSerialConsoleAccessStatusInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSerialConsoleAccessStatusRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetSerialConsoleAccessStatusRequest(_a0 *ec2.GetSerialConsoleAccessStatusInput) (*request.Request, *ec2.GetSerialConsoleAccessStatusOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetSerialConsoleAccessStatusInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetSerialConsoleAccessStatusOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetSerialConsoleAccessStatusInput) *ec2.GetSerialConsoleAccessStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetSerialConsoleAccessStatusOutput)
		}
	}

	return r0, r1
}

// GetSerialConsoleAccessStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetSerialConsoleAccessStatusWithContext(_a0 context.Context, _a1 *ec2.GetSerialConsoleAccessStatusInput, _a2 ...request.Option) (*ec2.GetSerialConsoleAccessStatusOutput, 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 *ec2.GetSerialConsoleAccessStatusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSerialConsoleAccessStatusInput, ...request.Option) *ec2.GetSerialConsoleAccessStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetSerialConsoleAccessStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetSerialConsoleAccessStatusInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayAttachmentPropagations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayAttachmentPropagations(_a0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetTransitGatewayAttachmentPropagationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayAttachmentPropagationsInput) *ec2.GetTransitGatewayAttachmentPropagationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayAttachmentPropagationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayAttachmentPropagationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetTransitGatewayAttachmentPropagationsPages(_a0 *ec2.GetTransitGatewayAttachmentPropagationsInput, _a1 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayAttachmentPropagationsInput, func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayAttachmentPropagationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetTransitGatewayAttachmentPropagationsPagesWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayAttachmentPropagationsInput, _a2 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, 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, *ec2.GetTransitGatewayAttachmentPropagationsInput, func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayAttachmentPropagationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayAttachmentPropagationsRequest(_a0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*request.Request, *ec2.GetTransitGatewayAttachmentPropagationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayAttachmentPropagationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetTransitGatewayAttachmentPropagationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayAttachmentPropagationsInput) *ec2.GetTransitGatewayAttachmentPropagationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
		}
	}

	return r0, r1
}

// GetTransitGatewayAttachmentPropagationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetTransitGatewayAttachmentPropagationsWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayAttachmentPropagationsInput, _a2 ...request.Option) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, 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 *ec2.GetTransitGatewayAttachmentPropagationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayAttachmentPropagationsInput, ...request.Option) *ec2.GetTransitGatewayAttachmentPropagationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayAttachmentPropagationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayMulticastDomainAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayMulticastDomainAssociations(_a0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayMulticastDomainAssociationsInput) *ec2.GetTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayMulticastDomainAssociationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayMulticastDomainAssociationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetTransitGatewayMulticastDomainAssociationsPages(_a0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, _a1 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayMulticastDomainAssociationsInput, func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayMulticastDomainAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, _a2 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, 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, *ec2.GetTransitGatewayMulticastDomainAssociationsInput, func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayMulticastDomainAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayMulticastDomainAssociationsRequest(_a0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.GetTransitGatewayMulticastDomainAssociationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayMulticastDomainAssociationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayMulticastDomainAssociationsInput) *ec2.GetTransitGatewayMulticastDomainAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	return r0, r1
}

// GetTransitGatewayMulticastDomainAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetTransitGatewayMulticastDomainAssociationsWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, _a2 ...request.Option) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, 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 *ec2.GetTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayMulticastDomainAssociationsInput, ...request.Option) *ec2.GetTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayMulticastDomainAssociationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayPrefixListReferences provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayPrefixListReferences(_a0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetTransitGatewayPrefixListReferencesOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayPrefixListReferencesInput) *ec2.GetTransitGatewayPrefixListReferencesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayPrefixListReferencesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayPrefixListReferencesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayPrefixListReferencesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetTransitGatewayPrefixListReferencesPages(_a0 *ec2.GetTransitGatewayPrefixListReferencesInput, _a1 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayPrefixListReferencesInput, func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayPrefixListReferencesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetTransitGatewayPrefixListReferencesPagesWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayPrefixListReferencesInput, _a2 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, 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, *ec2.GetTransitGatewayPrefixListReferencesInput, func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayPrefixListReferencesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayPrefixListReferencesRequest(_a0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*request.Request, *ec2.GetTransitGatewayPrefixListReferencesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayPrefixListReferencesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetTransitGatewayPrefixListReferencesOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayPrefixListReferencesInput) *ec2.GetTransitGatewayPrefixListReferencesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetTransitGatewayPrefixListReferencesOutput)
		}
	}

	return r0, r1
}

// GetTransitGatewayPrefixListReferencesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetTransitGatewayPrefixListReferencesWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayPrefixListReferencesInput, _a2 ...request.Option) (*ec2.GetTransitGatewayPrefixListReferencesOutput, 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 *ec2.GetTransitGatewayPrefixListReferencesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayPrefixListReferencesInput, ...request.Option) *ec2.GetTransitGatewayPrefixListReferencesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayPrefixListReferencesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayPrefixListReferencesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayRouteTableAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayRouteTableAssociations(_a0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetTransitGatewayRouteTableAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayRouteTableAssociationsInput) *ec2.GetTransitGatewayRouteTableAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayRouteTableAssociationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayRouteTableAssociationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetTransitGatewayRouteTableAssociationsPages(_a0 *ec2.GetTransitGatewayRouteTableAssociationsInput, _a1 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayRouteTableAssociationsInput, func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayRouteTableAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetTransitGatewayRouteTableAssociationsPagesWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayRouteTableAssociationsInput, _a2 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, 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, *ec2.GetTransitGatewayRouteTableAssociationsInput, func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayRouteTableAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayRouteTableAssociationsRequest(_a0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTableAssociationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayRouteTableAssociationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetTransitGatewayRouteTableAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayRouteTableAssociationsInput) *ec2.GetTransitGatewayRouteTableAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
		}
	}

	return r0, r1
}

// GetTransitGatewayRouteTableAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetTransitGatewayRouteTableAssociationsWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayRouteTableAssociationsInput, _a2 ...request.Option) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, 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 *ec2.GetTransitGatewayRouteTableAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayRouteTableAssociationsInput, ...request.Option) *ec2.GetTransitGatewayRouteTableAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayRouteTableAssociationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayRouteTablePropagations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayRouteTablePropagations(_a0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.GetTransitGatewayRouteTablePropagationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayRouteTablePropagationsInput) *ec2.GetTransitGatewayRouteTablePropagationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayRouteTablePropagationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetTransitGatewayRouteTablePropagationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) GetTransitGatewayRouteTablePropagationsPages(_a0 *ec2.GetTransitGatewayRouteTablePropagationsInput, _a1 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayRouteTablePropagationsInput, func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayRouteTablePropagationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) GetTransitGatewayRouteTablePropagationsPagesWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayRouteTablePropagationsInput, _a2 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, 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, *ec2.GetTransitGatewayRouteTablePropagationsInput, func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetTransitGatewayRouteTablePropagationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) GetTransitGatewayRouteTablePropagationsRequest(_a0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTablePropagationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.GetTransitGatewayRouteTablePropagationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.GetTransitGatewayRouteTablePropagationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.GetTransitGatewayRouteTablePropagationsInput) *ec2.GetTransitGatewayRouteTablePropagationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
		}
	}

	return r0, r1
}

// GetTransitGatewayRouteTablePropagationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) GetTransitGatewayRouteTablePropagationsWithContext(_a0 context.Context, _a1 *ec2.GetTransitGatewayRouteTablePropagationsInput, _a2 ...request.Option) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, 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 *ec2.GetTransitGatewayRouteTablePropagationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayRouteTablePropagationsInput, ...request.Option) *ec2.GetTransitGatewayRouteTablePropagationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayRouteTablePropagationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportClientVpnClientCertificateRevocationList provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportClientVpnClientCertificateRevocationList(_a0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ImportClientVpnClientCertificateRevocationListOutput
	if rf, ok := ret.Get(0).(func(*ec2.ImportClientVpnClientCertificateRevocationListInput) *ec2.ImportClientVpnClientCertificateRevocationListOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ImportClientVpnClientCertificateRevocationListInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportClientVpnClientCertificateRevocationListRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportClientVpnClientCertificateRevocationListRequest(_a0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ImportClientVpnClientCertificateRevocationListOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ImportClientVpnClientCertificateRevocationListInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ImportClientVpnClientCertificateRevocationListOutput
	if rf, ok := ret.Get(1).(func(*ec2.ImportClientVpnClientCertificateRevocationListInput) *ec2.ImportClientVpnClientCertificateRevocationListOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
		}
	}

	return r0, r1
}

// ImportClientVpnClientCertificateRevocationListWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ImportClientVpnClientCertificateRevocationListWithContext(_a0 context.Context, _a1 *ec2.ImportClientVpnClientCertificateRevocationListInput, _a2 ...request.Option) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, 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 *ec2.ImportClientVpnClientCertificateRevocationListOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportClientVpnClientCertificateRevocationListInput, ...request.Option) *ec2.ImportClientVpnClientCertificateRevocationListOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportClientVpnClientCertificateRevocationListInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportImage(_a0 *ec2.ImportImageInput) (*ec2.ImportImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ImportImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.ImportImageInput) *ec2.ImportImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ImportImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportImageRequest(_a0 *ec2.ImportImageInput) (*request.Request, *ec2.ImportImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ImportImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ImportImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.ImportImageInput) *ec2.ImportImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ImportImageOutput)
		}
	}

	return r0, r1
}

// ImportImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ImportImageWithContext(_a0 context.Context, _a1 *ec2.ImportImageInput, _a2 ...request.Option) (*ec2.ImportImageOutput, 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 *ec2.ImportImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportImageInput, ...request.Option) *ec2.ImportImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportInstance provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportInstance(_a0 *ec2.ImportInstanceInput) (*ec2.ImportInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ImportInstanceOutput
	if rf, ok := ret.Get(0).(func(*ec2.ImportInstanceInput) *ec2.ImportInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ImportInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportInstanceRequest(_a0 *ec2.ImportInstanceInput) (*request.Request, *ec2.ImportInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ImportInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ImportInstanceOutput
	if rf, ok := ret.Get(1).(func(*ec2.ImportInstanceInput) *ec2.ImportInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ImportInstanceOutput)
		}
	}

	return r0, r1
}

// ImportInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ImportInstanceWithContext(_a0 context.Context, _a1 *ec2.ImportInstanceInput, _a2 ...request.Option) (*ec2.ImportInstanceOutput, 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 *ec2.ImportInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportInstanceInput, ...request.Option) *ec2.ImportInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportKeyPair provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportKeyPair(_a0 *ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ImportKeyPairOutput
	if rf, ok := ret.Get(0).(func(*ec2.ImportKeyPairInput) *ec2.ImportKeyPairOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportKeyPairOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ImportKeyPairInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportKeyPairRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportKeyPairRequest(_a0 *ec2.ImportKeyPairInput) (*request.Request, *ec2.ImportKeyPairOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ImportKeyPairInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ImportKeyPairOutput
	if rf, ok := ret.Get(1).(func(*ec2.ImportKeyPairInput) *ec2.ImportKeyPairOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ImportKeyPairOutput)
		}
	}

	return r0, r1
}

// ImportKeyPairWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ImportKeyPairWithContext(_a0 context.Context, _a1 *ec2.ImportKeyPairInput, _a2 ...request.Option) (*ec2.ImportKeyPairOutput, 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 *ec2.ImportKeyPairOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportKeyPairInput, ...request.Option) *ec2.ImportKeyPairOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportKeyPairOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportKeyPairInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportSnapshot(_a0 *ec2.ImportSnapshotInput) (*ec2.ImportSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ImportSnapshotOutput
	if rf, ok := ret.Get(0).(func(*ec2.ImportSnapshotInput) *ec2.ImportSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ImportSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportSnapshotRequest(_a0 *ec2.ImportSnapshotInput) (*request.Request, *ec2.ImportSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ImportSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ImportSnapshotOutput
	if rf, ok := ret.Get(1).(func(*ec2.ImportSnapshotInput) *ec2.ImportSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ImportSnapshotOutput)
		}
	}

	return r0, r1
}

// ImportSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ImportSnapshotWithContext(_a0 context.Context, _a1 *ec2.ImportSnapshotInput, _a2 ...request.Option) (*ec2.ImportSnapshotOutput, 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 *ec2.ImportSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportSnapshotInput, ...request.Option) *ec2.ImportSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportVolume provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportVolume(_a0 *ec2.ImportVolumeInput) (*ec2.ImportVolumeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ImportVolumeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ImportVolumeInput) *ec2.ImportVolumeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportVolumeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ImportVolumeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportVolumeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ImportVolumeRequest(_a0 *ec2.ImportVolumeInput) (*request.Request, *ec2.ImportVolumeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ImportVolumeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ImportVolumeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ImportVolumeInput) *ec2.ImportVolumeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ImportVolumeOutput)
		}
	}

	return r0, r1
}

// ImportVolumeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ImportVolumeWithContext(_a0 context.Context, _a1 *ec2.ImportVolumeInput, _a2 ...request.Option) (*ec2.ImportVolumeOutput, 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 *ec2.ImportVolumeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportVolumeInput, ...request.Option) *ec2.ImportVolumeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportVolumeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportVolumeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyAddressAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyAddressAttribute(_a0 *ec2.ModifyAddressAttributeInput) (*ec2.ModifyAddressAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyAddressAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyAddressAttributeInput) *ec2.ModifyAddressAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyAddressAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyAddressAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyAddressAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyAddressAttributeRequest(_a0 *ec2.ModifyAddressAttributeInput) (*request.Request, *ec2.ModifyAddressAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyAddressAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyAddressAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyAddressAttributeInput) *ec2.ModifyAddressAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyAddressAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyAddressAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyAddressAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifyAddressAttributeInput, _a2 ...request.Option) (*ec2.ModifyAddressAttributeOutput, 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 *ec2.ModifyAddressAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyAddressAttributeInput, ...request.Option) *ec2.ModifyAddressAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyAddressAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyAddressAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyAvailabilityZoneGroup provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyAvailabilityZoneGroup(_a0 *ec2.ModifyAvailabilityZoneGroupInput) (*ec2.ModifyAvailabilityZoneGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyAvailabilityZoneGroupOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyAvailabilityZoneGroupInput) *ec2.ModifyAvailabilityZoneGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyAvailabilityZoneGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyAvailabilityZoneGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyAvailabilityZoneGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyAvailabilityZoneGroupRequest(_a0 *ec2.ModifyAvailabilityZoneGroupInput) (*request.Request, *ec2.ModifyAvailabilityZoneGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyAvailabilityZoneGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyAvailabilityZoneGroupOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyAvailabilityZoneGroupInput) *ec2.ModifyAvailabilityZoneGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyAvailabilityZoneGroupOutput)
		}
	}

	return r0, r1
}

// ModifyAvailabilityZoneGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyAvailabilityZoneGroupWithContext(_a0 context.Context, _a1 *ec2.ModifyAvailabilityZoneGroupInput, _a2 ...request.Option) (*ec2.ModifyAvailabilityZoneGroupOutput, 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 *ec2.ModifyAvailabilityZoneGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyAvailabilityZoneGroupInput, ...request.Option) *ec2.ModifyAvailabilityZoneGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyAvailabilityZoneGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyAvailabilityZoneGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyCapacityReservation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyCapacityReservation(_a0 *ec2.ModifyCapacityReservationInput) (*ec2.ModifyCapacityReservationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyCapacityReservationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyCapacityReservationInput) *ec2.ModifyCapacityReservationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyCapacityReservationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyCapacityReservationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyCapacityReservationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyCapacityReservationRequest(_a0 *ec2.ModifyCapacityReservationInput) (*request.Request, *ec2.ModifyCapacityReservationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyCapacityReservationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyCapacityReservationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyCapacityReservationInput) *ec2.ModifyCapacityReservationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyCapacityReservationOutput)
		}
	}

	return r0, r1
}

// ModifyCapacityReservationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyCapacityReservationWithContext(_a0 context.Context, _a1 *ec2.ModifyCapacityReservationInput, _a2 ...request.Option) (*ec2.ModifyCapacityReservationOutput, 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 *ec2.ModifyCapacityReservationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyCapacityReservationInput, ...request.Option) *ec2.ModifyCapacityReservationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyCapacityReservationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyCapacityReservationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyClientVpnEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyClientVpnEndpoint(_a0 *ec2.ModifyClientVpnEndpointInput) (*ec2.ModifyClientVpnEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyClientVpnEndpointOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyClientVpnEndpointInput) *ec2.ModifyClientVpnEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyClientVpnEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyClientVpnEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyClientVpnEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyClientVpnEndpointRequest(_a0 *ec2.ModifyClientVpnEndpointInput) (*request.Request, *ec2.ModifyClientVpnEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyClientVpnEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyClientVpnEndpointOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyClientVpnEndpointInput) *ec2.ModifyClientVpnEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyClientVpnEndpointOutput)
		}
	}

	return r0, r1
}

// ModifyClientVpnEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyClientVpnEndpointWithContext(_a0 context.Context, _a1 *ec2.ModifyClientVpnEndpointInput, _a2 ...request.Option) (*ec2.ModifyClientVpnEndpointOutput, 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 *ec2.ModifyClientVpnEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyClientVpnEndpointInput, ...request.Option) *ec2.ModifyClientVpnEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyClientVpnEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyClientVpnEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDefaultCreditSpecification provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyDefaultCreditSpecification(_a0 *ec2.ModifyDefaultCreditSpecificationInput) (*ec2.ModifyDefaultCreditSpecificationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyDefaultCreditSpecificationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyDefaultCreditSpecificationInput) *ec2.ModifyDefaultCreditSpecificationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyDefaultCreditSpecificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyDefaultCreditSpecificationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDefaultCreditSpecificationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyDefaultCreditSpecificationRequest(_a0 *ec2.ModifyDefaultCreditSpecificationInput) (*request.Request, *ec2.ModifyDefaultCreditSpecificationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyDefaultCreditSpecificationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyDefaultCreditSpecificationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyDefaultCreditSpecificationInput) *ec2.ModifyDefaultCreditSpecificationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyDefaultCreditSpecificationOutput)
		}
	}

	return r0, r1
}

// ModifyDefaultCreditSpecificationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyDefaultCreditSpecificationWithContext(_a0 context.Context, _a1 *ec2.ModifyDefaultCreditSpecificationInput, _a2 ...request.Option) (*ec2.ModifyDefaultCreditSpecificationOutput, 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 *ec2.ModifyDefaultCreditSpecificationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyDefaultCreditSpecificationInput, ...request.Option) *ec2.ModifyDefaultCreditSpecificationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyDefaultCreditSpecificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyDefaultCreditSpecificationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyEbsDefaultKmsKeyId provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyEbsDefaultKmsKeyId(_a0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyEbsDefaultKmsKeyIdInput) *ec2.ModifyEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyEbsDefaultKmsKeyIdInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyEbsDefaultKmsKeyIdRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyEbsDefaultKmsKeyIdRequest(_a0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ModifyEbsDefaultKmsKeyIdOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyEbsDefaultKmsKeyIdInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyEbsDefaultKmsKeyIdInput) *ec2.ModifyEbsDefaultKmsKeyIdOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
		}
	}

	return r0, r1
}

// ModifyEbsDefaultKmsKeyIdWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyEbsDefaultKmsKeyIdWithContext(_a0 context.Context, _a1 *ec2.ModifyEbsDefaultKmsKeyIdInput, _a2 ...request.Option) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, 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 *ec2.ModifyEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyEbsDefaultKmsKeyIdInput, ...request.Option) *ec2.ModifyEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyEbsDefaultKmsKeyIdInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyFleet provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyFleet(_a0 *ec2.ModifyFleetInput) (*ec2.ModifyFleetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyFleetOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyFleetInput) *ec2.ModifyFleetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyFleetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyFleetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyFleetRequest(_a0 *ec2.ModifyFleetInput) (*request.Request, *ec2.ModifyFleetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyFleetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyFleetOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyFleetInput) *ec2.ModifyFleetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyFleetOutput)
		}
	}

	return r0, r1
}

// ModifyFleetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyFleetWithContext(_a0 context.Context, _a1 *ec2.ModifyFleetInput, _a2 ...request.Option) (*ec2.ModifyFleetOutput, 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 *ec2.ModifyFleetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyFleetInput, ...request.Option) *ec2.ModifyFleetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyFleetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyFpgaImageAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyFpgaImageAttribute(_a0 *ec2.ModifyFpgaImageAttributeInput) (*ec2.ModifyFpgaImageAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyFpgaImageAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyFpgaImageAttributeInput) *ec2.ModifyFpgaImageAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyFpgaImageAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyFpgaImageAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyFpgaImageAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyFpgaImageAttributeRequest(_a0 *ec2.ModifyFpgaImageAttributeInput) (*request.Request, *ec2.ModifyFpgaImageAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyFpgaImageAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyFpgaImageAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyFpgaImageAttributeInput) *ec2.ModifyFpgaImageAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyFpgaImageAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyFpgaImageAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyFpgaImageAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifyFpgaImageAttributeInput, _a2 ...request.Option) (*ec2.ModifyFpgaImageAttributeOutput, 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 *ec2.ModifyFpgaImageAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyFpgaImageAttributeInput, ...request.Option) *ec2.ModifyFpgaImageAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyFpgaImageAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyFpgaImageAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyHosts provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyHosts(_a0 *ec2.ModifyHostsInput) (*ec2.ModifyHostsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyHostsOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyHostsInput) *ec2.ModifyHostsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyHostsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyHostsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyHostsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyHostsRequest(_a0 *ec2.ModifyHostsInput) (*request.Request, *ec2.ModifyHostsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyHostsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyHostsOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyHostsInput) *ec2.ModifyHostsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyHostsOutput)
		}
	}

	return r0, r1
}

// ModifyHostsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyHostsWithContext(_a0 context.Context, _a1 *ec2.ModifyHostsInput, _a2 ...request.Option) (*ec2.ModifyHostsOutput, 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 *ec2.ModifyHostsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyHostsInput, ...request.Option) *ec2.ModifyHostsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyHostsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyHostsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyIdFormat provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyIdFormat(_a0 *ec2.ModifyIdFormatInput) (*ec2.ModifyIdFormatOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyIdFormatOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyIdFormatInput) *ec2.ModifyIdFormatOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIdFormatOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyIdFormatInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyIdFormatRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyIdFormatRequest(_a0 *ec2.ModifyIdFormatInput) (*request.Request, *ec2.ModifyIdFormatOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyIdFormatInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyIdFormatOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyIdFormatInput) *ec2.ModifyIdFormatOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyIdFormatOutput)
		}
	}

	return r0, r1
}

// ModifyIdFormatWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyIdFormatWithContext(_a0 context.Context, _a1 *ec2.ModifyIdFormatInput, _a2 ...request.Option) (*ec2.ModifyIdFormatOutput, 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 *ec2.ModifyIdFormatOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIdFormatInput, ...request.Option) *ec2.ModifyIdFormatOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIdFormatOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIdFormatInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyIdentityIdFormat provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyIdentityIdFormat(_a0 *ec2.ModifyIdentityIdFormatInput) (*ec2.ModifyIdentityIdFormatOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyIdentityIdFormatOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyIdentityIdFormatInput) *ec2.ModifyIdentityIdFormatOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIdentityIdFormatOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyIdentityIdFormatInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyIdentityIdFormatRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyIdentityIdFormatRequest(_a0 *ec2.ModifyIdentityIdFormatInput) (*request.Request, *ec2.ModifyIdentityIdFormatOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyIdentityIdFormatInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyIdentityIdFormatOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyIdentityIdFormatInput) *ec2.ModifyIdentityIdFormatOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyIdentityIdFormatOutput)
		}
	}

	return r0, r1
}

// ModifyIdentityIdFormatWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyIdentityIdFormatWithContext(_a0 context.Context, _a1 *ec2.ModifyIdentityIdFormatInput, _a2 ...request.Option) (*ec2.ModifyIdentityIdFormatOutput, 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 *ec2.ModifyIdentityIdFormatOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIdentityIdFormatInput, ...request.Option) *ec2.ModifyIdentityIdFormatOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIdentityIdFormatOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIdentityIdFormatInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyImageAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyImageAttribute(_a0 *ec2.ModifyImageAttributeInput) (*ec2.ModifyImageAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyImageAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyImageAttributeInput) *ec2.ModifyImageAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyImageAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyImageAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyImageAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyImageAttributeRequest(_a0 *ec2.ModifyImageAttributeInput) (*request.Request, *ec2.ModifyImageAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyImageAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyImageAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyImageAttributeInput) *ec2.ModifyImageAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyImageAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyImageAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyImageAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifyImageAttributeInput, _a2 ...request.Option) (*ec2.ModifyImageAttributeOutput, 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 *ec2.ModifyImageAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyImageAttributeInput, ...request.Option) *ec2.ModifyImageAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyImageAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyImageAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceAttribute(_a0 *ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyInstanceAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceAttributeInput) *ec2.ModifyInstanceAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceAttributeRequest(_a0 *ec2.ModifyInstanceAttributeInput) (*request.Request, *ec2.ModifyInstanceAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyInstanceAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceAttributeInput) *ec2.ModifyInstanceAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyInstanceAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyInstanceAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyInstanceAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifyInstanceAttributeInput, _a2 ...request.Option) (*ec2.ModifyInstanceAttributeOutput, 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 *ec2.ModifyInstanceAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceAttributeInput, ...request.Option) *ec2.ModifyInstanceAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceCapacityReservationAttributes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceCapacityReservationAttributes(_a0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyInstanceCapacityReservationAttributesOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceCapacityReservationAttributesInput) *ec2.ModifyInstanceCapacityReservationAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceCapacityReservationAttributesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceCapacityReservationAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceCapacityReservationAttributesRequest(_a0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*request.Request, *ec2.ModifyInstanceCapacityReservationAttributesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceCapacityReservationAttributesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyInstanceCapacityReservationAttributesOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceCapacityReservationAttributesInput) *ec2.ModifyInstanceCapacityReservationAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
		}
	}

	return r0, r1
}

// ModifyInstanceCapacityReservationAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyInstanceCapacityReservationAttributesWithContext(_a0 context.Context, _a1 *ec2.ModifyInstanceCapacityReservationAttributesInput, _a2 ...request.Option) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, 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 *ec2.ModifyInstanceCapacityReservationAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceCapacityReservationAttributesInput, ...request.Option) *ec2.ModifyInstanceCapacityReservationAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceCapacityReservationAttributesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceCreditSpecification provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceCreditSpecification(_a0 *ec2.ModifyInstanceCreditSpecificationInput) (*ec2.ModifyInstanceCreditSpecificationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyInstanceCreditSpecificationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceCreditSpecificationInput) *ec2.ModifyInstanceCreditSpecificationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceCreditSpecificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceCreditSpecificationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceCreditSpecificationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceCreditSpecificationRequest(_a0 *ec2.ModifyInstanceCreditSpecificationInput) (*request.Request, *ec2.ModifyInstanceCreditSpecificationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceCreditSpecificationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyInstanceCreditSpecificationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceCreditSpecificationInput) *ec2.ModifyInstanceCreditSpecificationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyInstanceCreditSpecificationOutput)
		}
	}

	return r0, r1
}

// ModifyInstanceCreditSpecificationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyInstanceCreditSpecificationWithContext(_a0 context.Context, _a1 *ec2.ModifyInstanceCreditSpecificationInput, _a2 ...request.Option) (*ec2.ModifyInstanceCreditSpecificationOutput, 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 *ec2.ModifyInstanceCreditSpecificationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceCreditSpecificationInput, ...request.Option) *ec2.ModifyInstanceCreditSpecificationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceCreditSpecificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceCreditSpecificationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceEventStartTime provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceEventStartTime(_a0 *ec2.ModifyInstanceEventStartTimeInput) (*ec2.ModifyInstanceEventStartTimeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyInstanceEventStartTimeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceEventStartTimeInput) *ec2.ModifyInstanceEventStartTimeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceEventStartTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceEventStartTimeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceEventStartTimeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceEventStartTimeRequest(_a0 *ec2.ModifyInstanceEventStartTimeInput) (*request.Request, *ec2.ModifyInstanceEventStartTimeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceEventStartTimeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyInstanceEventStartTimeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceEventStartTimeInput) *ec2.ModifyInstanceEventStartTimeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyInstanceEventStartTimeOutput)
		}
	}

	return r0, r1
}

// ModifyInstanceEventStartTimeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyInstanceEventStartTimeWithContext(_a0 context.Context, _a1 *ec2.ModifyInstanceEventStartTimeInput, _a2 ...request.Option) (*ec2.ModifyInstanceEventStartTimeOutput, 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 *ec2.ModifyInstanceEventStartTimeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceEventStartTimeInput, ...request.Option) *ec2.ModifyInstanceEventStartTimeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceEventStartTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceEventStartTimeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceMetadataOptions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceMetadataOptions(_a0 *ec2.ModifyInstanceMetadataOptionsInput) (*ec2.ModifyInstanceMetadataOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyInstanceMetadataOptionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceMetadataOptionsInput) *ec2.ModifyInstanceMetadataOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceMetadataOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceMetadataOptionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstanceMetadataOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstanceMetadataOptionsRequest(_a0 *ec2.ModifyInstanceMetadataOptionsInput) (*request.Request, *ec2.ModifyInstanceMetadataOptionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstanceMetadataOptionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyInstanceMetadataOptionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstanceMetadataOptionsInput) *ec2.ModifyInstanceMetadataOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyInstanceMetadataOptionsOutput)
		}
	}

	return r0, r1
}

// ModifyInstanceMetadataOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyInstanceMetadataOptionsWithContext(_a0 context.Context, _a1 *ec2.ModifyInstanceMetadataOptionsInput, _a2 ...request.Option) (*ec2.ModifyInstanceMetadataOptionsOutput, 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 *ec2.ModifyInstanceMetadataOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceMetadataOptionsInput, ...request.Option) *ec2.ModifyInstanceMetadataOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceMetadataOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceMetadataOptionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstancePlacement provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstancePlacement(_a0 *ec2.ModifyInstancePlacementInput) (*ec2.ModifyInstancePlacementOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyInstancePlacementOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstancePlacementInput) *ec2.ModifyInstancePlacementOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstancePlacementOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstancePlacementInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyInstancePlacementRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyInstancePlacementRequest(_a0 *ec2.ModifyInstancePlacementInput) (*request.Request, *ec2.ModifyInstancePlacementOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyInstancePlacementInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyInstancePlacementOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyInstancePlacementInput) *ec2.ModifyInstancePlacementOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyInstancePlacementOutput)
		}
	}

	return r0, r1
}

// ModifyInstancePlacementWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyInstancePlacementWithContext(_a0 context.Context, _a1 *ec2.ModifyInstancePlacementInput, _a2 ...request.Option) (*ec2.ModifyInstancePlacementOutput, 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 *ec2.ModifyInstancePlacementOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstancePlacementInput, ...request.Option) *ec2.ModifyInstancePlacementOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstancePlacementOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstancePlacementInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyLaunchTemplate provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyLaunchTemplate(_a0 *ec2.ModifyLaunchTemplateInput) (*ec2.ModifyLaunchTemplateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyLaunchTemplateOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyLaunchTemplateInput) *ec2.ModifyLaunchTemplateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyLaunchTemplateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyLaunchTemplateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyLaunchTemplateRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyLaunchTemplateRequest(_a0 *ec2.ModifyLaunchTemplateInput) (*request.Request, *ec2.ModifyLaunchTemplateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyLaunchTemplateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyLaunchTemplateOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyLaunchTemplateInput) *ec2.ModifyLaunchTemplateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyLaunchTemplateOutput)
		}
	}

	return r0, r1
}

// ModifyLaunchTemplateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyLaunchTemplateWithContext(_a0 context.Context, _a1 *ec2.ModifyLaunchTemplateInput, _a2 ...request.Option) (*ec2.ModifyLaunchTemplateOutput, 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 *ec2.ModifyLaunchTemplateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyLaunchTemplateInput, ...request.Option) *ec2.ModifyLaunchTemplateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyLaunchTemplateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyLaunchTemplateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyManagedPrefixList provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyManagedPrefixList(_a0 *ec2.ModifyManagedPrefixListInput) (*ec2.ModifyManagedPrefixListOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyManagedPrefixListOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyManagedPrefixListInput) *ec2.ModifyManagedPrefixListOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyManagedPrefixListOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyManagedPrefixListInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyManagedPrefixListRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyManagedPrefixListRequest(_a0 *ec2.ModifyManagedPrefixListInput) (*request.Request, *ec2.ModifyManagedPrefixListOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyManagedPrefixListInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyManagedPrefixListOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyManagedPrefixListInput) *ec2.ModifyManagedPrefixListOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyManagedPrefixListOutput)
		}
	}

	return r0, r1
}

// ModifyManagedPrefixListWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyManagedPrefixListWithContext(_a0 context.Context, _a1 *ec2.ModifyManagedPrefixListInput, _a2 ...request.Option) (*ec2.ModifyManagedPrefixListOutput, 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 *ec2.ModifyManagedPrefixListOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyManagedPrefixListInput, ...request.Option) *ec2.ModifyManagedPrefixListOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyManagedPrefixListOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyManagedPrefixListInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyNetworkInterfaceAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyNetworkInterfaceAttribute(_a0 *ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyNetworkInterfaceAttributeInput) *ec2.ModifyNetworkInterfaceAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyNetworkInterfaceAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyNetworkInterfaceAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyNetworkInterfaceAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyNetworkInterfaceAttributeRequest(_a0 *ec2.ModifyNetworkInterfaceAttributeInput) (*request.Request, *ec2.ModifyNetworkInterfaceAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyNetworkInterfaceAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyNetworkInterfaceAttributeInput) *ec2.ModifyNetworkInterfaceAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyNetworkInterfaceAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyNetworkInterfaceAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyNetworkInterfaceAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifyNetworkInterfaceAttributeInput, _a2 ...request.Option) (*ec2.ModifyNetworkInterfaceAttributeOutput, 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 *ec2.ModifyNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyNetworkInterfaceAttributeInput, ...request.Option) *ec2.ModifyNetworkInterfaceAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyNetworkInterfaceAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyNetworkInterfaceAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyReservedInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyReservedInstances(_a0 *ec2.ModifyReservedInstancesInput) (*ec2.ModifyReservedInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyReservedInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyReservedInstancesInput) *ec2.ModifyReservedInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyReservedInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyReservedInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyReservedInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyReservedInstancesRequest(_a0 *ec2.ModifyReservedInstancesInput) (*request.Request, *ec2.ModifyReservedInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyReservedInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyReservedInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyReservedInstancesInput) *ec2.ModifyReservedInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyReservedInstancesOutput)
		}
	}

	return r0, r1
}

// ModifyReservedInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyReservedInstancesWithContext(_a0 context.Context, _a1 *ec2.ModifyReservedInstancesInput, _a2 ...request.Option) (*ec2.ModifyReservedInstancesOutput, 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 *ec2.ModifyReservedInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyReservedInstancesInput, ...request.Option) *ec2.ModifyReservedInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyReservedInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyReservedInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifySnapshotAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifySnapshotAttribute(_a0 *ec2.ModifySnapshotAttributeInput) (*ec2.ModifySnapshotAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifySnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifySnapshotAttributeInput) *ec2.ModifySnapshotAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifySnapshotAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifySnapshotAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifySnapshotAttributeRequest(_a0 *ec2.ModifySnapshotAttributeInput) (*request.Request, *ec2.ModifySnapshotAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifySnapshotAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifySnapshotAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifySnapshotAttributeInput) *ec2.ModifySnapshotAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifySnapshotAttributeOutput)
		}
	}

	return r0, r1
}

// ModifySnapshotAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifySnapshotAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifySnapshotAttributeInput, _a2 ...request.Option) (*ec2.ModifySnapshotAttributeOutput, 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 *ec2.ModifySnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySnapshotAttributeInput, ...request.Option) *ec2.ModifySnapshotAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifySnapshotAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifySpotFleetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifySpotFleetRequest(_a0 *ec2.ModifySpotFleetRequestInput) (*ec2.ModifySpotFleetRequestOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifySpotFleetRequestOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifySpotFleetRequestInput) *ec2.ModifySpotFleetRequestOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySpotFleetRequestOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifySpotFleetRequestInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifySpotFleetRequestRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifySpotFleetRequestRequest(_a0 *ec2.ModifySpotFleetRequestInput) (*request.Request, *ec2.ModifySpotFleetRequestOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifySpotFleetRequestInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifySpotFleetRequestOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifySpotFleetRequestInput) *ec2.ModifySpotFleetRequestOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifySpotFleetRequestOutput)
		}
	}

	return r0, r1
}

// ModifySpotFleetRequestWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifySpotFleetRequestWithContext(_a0 context.Context, _a1 *ec2.ModifySpotFleetRequestInput, _a2 ...request.Option) (*ec2.ModifySpotFleetRequestOutput, 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 *ec2.ModifySpotFleetRequestOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySpotFleetRequestInput, ...request.Option) *ec2.ModifySpotFleetRequestOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySpotFleetRequestOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifySpotFleetRequestInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifySubnetAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifySubnetAttribute(_a0 *ec2.ModifySubnetAttributeInput) (*ec2.ModifySubnetAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifySubnetAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifySubnetAttributeInput) *ec2.ModifySubnetAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySubnetAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifySubnetAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifySubnetAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifySubnetAttributeRequest(_a0 *ec2.ModifySubnetAttributeInput) (*request.Request, *ec2.ModifySubnetAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifySubnetAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifySubnetAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifySubnetAttributeInput) *ec2.ModifySubnetAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifySubnetAttributeOutput)
		}
	}

	return r0, r1
}

// ModifySubnetAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifySubnetAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifySubnetAttributeInput, _a2 ...request.Option) (*ec2.ModifySubnetAttributeOutput, 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 *ec2.ModifySubnetAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySubnetAttributeInput, ...request.Option) *ec2.ModifySubnetAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySubnetAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifySubnetAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTrafficMirrorFilterNetworkServices provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTrafficMirrorFilterNetworkServices(_a0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTrafficMirrorFilterNetworkServicesInput) *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTrafficMirrorFilterNetworkServicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTrafficMirrorFilterNetworkServicesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTrafficMirrorFilterNetworkServicesRequest(_a0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTrafficMirrorFilterNetworkServicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTrafficMirrorFilterNetworkServicesInput) *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
		}
	}

	return r0, r1
}

// ModifyTrafficMirrorFilterNetworkServicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyTrafficMirrorFilterNetworkServicesWithContext(_a0 context.Context, _a1 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, _a2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, 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 *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, ...request.Option) *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTrafficMirrorFilterRule provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTrafficMirrorFilterRule(_a0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTrafficMirrorFilterRuleInput) *ec2.ModifyTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorFilterRuleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTrafficMirrorFilterRuleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTrafficMirrorFilterRuleRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTrafficMirrorFilterRuleRequest(_a0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterRuleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTrafficMirrorFilterRuleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTrafficMirrorFilterRuleInput) *ec2.ModifyTrafficMirrorFilterRuleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyTrafficMirrorFilterRuleOutput)
		}
	}

	return r0, r1
}

// ModifyTrafficMirrorFilterRuleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyTrafficMirrorFilterRuleWithContext(_a0 context.Context, _a1 *ec2.ModifyTrafficMirrorFilterRuleInput, _a2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterRuleOutput, 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 *ec2.ModifyTrafficMirrorFilterRuleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorFilterRuleInput, ...request.Option) *ec2.ModifyTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorFilterRuleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTrafficMirrorFilterRuleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTrafficMirrorSession provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTrafficMirrorSession(_a0 *ec2.ModifyTrafficMirrorSessionInput) (*ec2.ModifyTrafficMirrorSessionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyTrafficMirrorSessionOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTrafficMirrorSessionInput) *ec2.ModifyTrafficMirrorSessionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorSessionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTrafficMirrorSessionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTrafficMirrorSessionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTrafficMirrorSessionRequest(_a0 *ec2.ModifyTrafficMirrorSessionInput) (*request.Request, *ec2.ModifyTrafficMirrorSessionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTrafficMirrorSessionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyTrafficMirrorSessionOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTrafficMirrorSessionInput) *ec2.ModifyTrafficMirrorSessionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyTrafficMirrorSessionOutput)
		}
	}

	return r0, r1
}

// ModifyTrafficMirrorSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyTrafficMirrorSessionWithContext(_a0 context.Context, _a1 *ec2.ModifyTrafficMirrorSessionInput, _a2 ...request.Option) (*ec2.ModifyTrafficMirrorSessionOutput, 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 *ec2.ModifyTrafficMirrorSessionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorSessionInput, ...request.Option) *ec2.ModifyTrafficMirrorSessionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorSessionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTrafficMirrorSessionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTransitGateway provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTransitGateway(_a0 *ec2.ModifyTransitGatewayInput) (*ec2.ModifyTransitGatewayOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyTransitGatewayOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTransitGatewayInput) *ec2.ModifyTransitGatewayOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTransitGatewayInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTransitGatewayPrefixListReference provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTransitGatewayPrefixListReference(_a0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTransitGatewayPrefixListReferenceInput) *ec2.ModifyTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTransitGatewayPrefixListReferenceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTransitGatewayPrefixListReferenceRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTransitGatewayPrefixListReferenceRequest(_a0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.ModifyTransitGatewayPrefixListReferenceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTransitGatewayPrefixListReferenceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTransitGatewayPrefixListReferenceInput) *ec2.ModifyTransitGatewayPrefixListReferenceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
		}
	}

	return r0, r1
}

// ModifyTransitGatewayPrefixListReferenceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyTransitGatewayPrefixListReferenceWithContext(_a0 context.Context, _a1 *ec2.ModifyTransitGatewayPrefixListReferenceInput, _a2 ...request.Option) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, 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 *ec2.ModifyTransitGatewayPrefixListReferenceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayPrefixListReferenceInput, ...request.Option) *ec2.ModifyTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTransitGatewayPrefixListReferenceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTransitGatewayRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTransitGatewayRequest(_a0 *ec2.ModifyTransitGatewayInput) (*request.Request, *ec2.ModifyTransitGatewayOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTransitGatewayInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyTransitGatewayOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTransitGatewayInput) *ec2.ModifyTransitGatewayOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyTransitGatewayOutput)
		}
	}

	return r0, r1
}

// ModifyTransitGatewayVpcAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTransitGatewayVpcAttachment(_a0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTransitGatewayVpcAttachmentInput) *ec2.ModifyTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTransitGatewayVpcAttachmentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTransitGatewayVpcAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyTransitGatewayVpcAttachmentRequest(_a0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.ModifyTransitGatewayVpcAttachmentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyTransitGatewayVpcAttachmentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyTransitGatewayVpcAttachmentInput) *ec2.ModifyTransitGatewayVpcAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
		}
	}

	return r0, r1
}

// ModifyTransitGatewayVpcAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyTransitGatewayVpcAttachmentWithContext(_a0 context.Context, _a1 *ec2.ModifyTransitGatewayVpcAttachmentInput, _a2 ...request.Option) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, 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 *ec2.ModifyTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayVpcAttachmentInput, ...request.Option) *ec2.ModifyTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTransitGatewayVpcAttachmentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyTransitGatewayWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyTransitGatewayWithContext(_a0 context.Context, _a1 *ec2.ModifyTransitGatewayInput, _a2 ...request.Option) (*ec2.ModifyTransitGatewayOutput, 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 *ec2.ModifyTransitGatewayOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayInput, ...request.Option) *ec2.ModifyTransitGatewayOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTransitGatewayInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVolume provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVolume(_a0 *ec2.ModifyVolumeInput) (*ec2.ModifyVolumeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVolumeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVolumeInput) *ec2.ModifyVolumeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVolumeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVolumeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVolumeAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVolumeAttribute(_a0 *ec2.ModifyVolumeAttributeInput) (*ec2.ModifyVolumeAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVolumeAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVolumeAttributeInput) *ec2.ModifyVolumeAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVolumeAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVolumeAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVolumeAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVolumeAttributeRequest(_a0 *ec2.ModifyVolumeAttributeInput) (*request.Request, *ec2.ModifyVolumeAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVolumeAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVolumeAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVolumeAttributeInput) *ec2.ModifyVolumeAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVolumeAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyVolumeAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVolumeAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifyVolumeAttributeInput, _a2 ...request.Option) (*ec2.ModifyVolumeAttributeOutput, 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 *ec2.ModifyVolumeAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVolumeAttributeInput, ...request.Option) *ec2.ModifyVolumeAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVolumeAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVolumeAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVolumeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVolumeRequest(_a0 *ec2.ModifyVolumeInput) (*request.Request, *ec2.ModifyVolumeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVolumeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVolumeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVolumeInput) *ec2.ModifyVolumeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVolumeOutput)
		}
	}

	return r0, r1
}

// ModifyVolumeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVolumeWithContext(_a0 context.Context, _a1 *ec2.ModifyVolumeInput, _a2 ...request.Option) (*ec2.ModifyVolumeOutput, 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 *ec2.ModifyVolumeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVolumeInput, ...request.Option) *ec2.ModifyVolumeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVolumeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVolumeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcAttribute(_a0 *ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpcAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcAttributeInput) *ec2.ModifyVpcAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcAttributeRequest(_a0 *ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpcAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcAttributeInput) *ec2.ModifyVpcAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpcAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyVpcAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpcAttributeWithContext(_a0 context.Context, _a1 *ec2.ModifyVpcAttributeInput, _a2 ...request.Option) (*ec2.ModifyVpcAttributeOutput, 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 *ec2.ModifyVpcAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcAttributeInput, ...request.Option) *ec2.ModifyVpcAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcEndpoint(_a0 *ec2.ModifyVpcEndpointInput) (*ec2.ModifyVpcEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpcEndpointOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcEndpointInput) *ec2.ModifyVpcEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcEndpointConnectionNotification provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcEndpointConnectionNotification(_a0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpcEndpointConnectionNotificationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcEndpointConnectionNotificationInput) *ec2.ModifyVpcEndpointConnectionNotificationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcEndpointConnectionNotificationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcEndpointConnectionNotificationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcEndpointConnectionNotificationRequest(_a0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.ModifyVpcEndpointConnectionNotificationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcEndpointConnectionNotificationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpcEndpointConnectionNotificationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcEndpointConnectionNotificationInput) *ec2.ModifyVpcEndpointConnectionNotificationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
		}
	}

	return r0, r1
}

// ModifyVpcEndpointConnectionNotificationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpcEndpointConnectionNotificationWithContext(_a0 context.Context, _a1 *ec2.ModifyVpcEndpointConnectionNotificationInput, _a2 ...request.Option) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, 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 *ec2.ModifyVpcEndpointConnectionNotificationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointConnectionNotificationInput, ...request.Option) *ec2.ModifyVpcEndpointConnectionNotificationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointConnectionNotificationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcEndpointRequest(_a0 *ec2.ModifyVpcEndpointInput) (*request.Request, *ec2.ModifyVpcEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpcEndpointOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcEndpointInput) *ec2.ModifyVpcEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpcEndpointOutput)
		}
	}

	return r0, r1
}

// ModifyVpcEndpointServiceConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcEndpointServiceConfiguration(_a0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpcEndpointServiceConfigurationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcEndpointServiceConfigurationInput) *ec2.ModifyVpcEndpointServiceConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcEndpointServiceConfigurationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcEndpointServiceConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcEndpointServiceConfigurationRequest(_a0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.ModifyVpcEndpointServiceConfigurationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcEndpointServiceConfigurationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpcEndpointServiceConfigurationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcEndpointServiceConfigurationInput) *ec2.ModifyVpcEndpointServiceConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
		}
	}

	return r0, r1
}

// ModifyVpcEndpointServiceConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpcEndpointServiceConfigurationWithContext(_a0 context.Context, _a1 *ec2.ModifyVpcEndpointServiceConfigurationInput, _a2 ...request.Option) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, 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 *ec2.ModifyVpcEndpointServiceConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointServiceConfigurationInput, ...request.Option) *ec2.ModifyVpcEndpointServiceConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointServiceConfigurationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcEndpointServicePermissions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcEndpointServicePermissions(_a0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpcEndpointServicePermissionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcEndpointServicePermissionsInput) *ec2.ModifyVpcEndpointServicePermissionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointServicePermissionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcEndpointServicePermissionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcEndpointServicePermissionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcEndpointServicePermissionsRequest(_a0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*request.Request, *ec2.ModifyVpcEndpointServicePermissionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcEndpointServicePermissionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpcEndpointServicePermissionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcEndpointServicePermissionsInput) *ec2.ModifyVpcEndpointServicePermissionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpcEndpointServicePermissionsOutput)
		}
	}

	return r0, r1
}

// ModifyVpcEndpointServicePermissionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpcEndpointServicePermissionsWithContext(_a0 context.Context, _a1 *ec2.ModifyVpcEndpointServicePermissionsInput, _a2 ...request.Option) (*ec2.ModifyVpcEndpointServicePermissionsOutput, 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 *ec2.ModifyVpcEndpointServicePermissionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointServicePermissionsInput, ...request.Option) *ec2.ModifyVpcEndpointServicePermissionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointServicePermissionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointServicePermissionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpcEndpointWithContext(_a0 context.Context, _a1 *ec2.ModifyVpcEndpointInput, _a2 ...request.Option) (*ec2.ModifyVpcEndpointOutput, 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 *ec2.ModifyVpcEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointInput, ...request.Option) *ec2.ModifyVpcEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcPeeringConnectionOptions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcPeeringConnectionOptions(_a0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpcPeeringConnectionOptionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcPeeringConnectionOptionsInput) *ec2.ModifyVpcPeeringConnectionOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcPeeringConnectionOptionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcPeeringConnectionOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcPeeringConnectionOptionsRequest(_a0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*request.Request, *ec2.ModifyVpcPeeringConnectionOptionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcPeeringConnectionOptionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpcPeeringConnectionOptionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcPeeringConnectionOptionsInput) *ec2.ModifyVpcPeeringConnectionOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
		}
	}

	return r0, r1
}

// ModifyVpcPeeringConnectionOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpcPeeringConnectionOptionsWithContext(_a0 context.Context, _a1 *ec2.ModifyVpcPeeringConnectionOptionsInput, _a2 ...request.Option) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, 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 *ec2.ModifyVpcPeeringConnectionOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcPeeringConnectionOptionsInput, ...request.Option) *ec2.ModifyVpcPeeringConnectionOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcPeeringConnectionOptionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcTenancy provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcTenancy(_a0 *ec2.ModifyVpcTenancyInput) (*ec2.ModifyVpcTenancyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpcTenancyOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcTenancyInput) *ec2.ModifyVpcTenancyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcTenancyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcTenancyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpcTenancyRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpcTenancyRequest(_a0 *ec2.ModifyVpcTenancyInput) (*request.Request, *ec2.ModifyVpcTenancyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpcTenancyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpcTenancyOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpcTenancyInput) *ec2.ModifyVpcTenancyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpcTenancyOutput)
		}
	}

	return r0, r1
}

// ModifyVpcTenancyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpcTenancyWithContext(_a0 context.Context, _a1 *ec2.ModifyVpcTenancyInput, _a2 ...request.Option) (*ec2.ModifyVpcTenancyOutput, 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 *ec2.ModifyVpcTenancyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcTenancyInput, ...request.Option) *ec2.ModifyVpcTenancyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcTenancyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcTenancyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpnConnection provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpnConnection(_a0 *ec2.ModifyVpnConnectionInput) (*ec2.ModifyVpnConnectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpnConnectionOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpnConnectionInput) *ec2.ModifyVpnConnectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnConnectionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpnConnectionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpnConnectionOptions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpnConnectionOptions(_a0 *ec2.ModifyVpnConnectionOptionsInput) (*ec2.ModifyVpnConnectionOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpnConnectionOptionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpnConnectionOptionsInput) *ec2.ModifyVpnConnectionOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnConnectionOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpnConnectionOptionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpnConnectionOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpnConnectionOptionsRequest(_a0 *ec2.ModifyVpnConnectionOptionsInput) (*request.Request, *ec2.ModifyVpnConnectionOptionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpnConnectionOptionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpnConnectionOptionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpnConnectionOptionsInput) *ec2.ModifyVpnConnectionOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpnConnectionOptionsOutput)
		}
	}

	return r0, r1
}

// ModifyVpnConnectionOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpnConnectionOptionsWithContext(_a0 context.Context, _a1 *ec2.ModifyVpnConnectionOptionsInput, _a2 ...request.Option) (*ec2.ModifyVpnConnectionOptionsOutput, 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 *ec2.ModifyVpnConnectionOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnConnectionOptionsInput, ...request.Option) *ec2.ModifyVpnConnectionOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnConnectionOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpnConnectionOptionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpnConnectionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpnConnectionRequest(_a0 *ec2.ModifyVpnConnectionInput) (*request.Request, *ec2.ModifyVpnConnectionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpnConnectionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpnConnectionOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpnConnectionInput) *ec2.ModifyVpnConnectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpnConnectionOutput)
		}
	}

	return r0, r1
}

// ModifyVpnConnectionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpnConnectionWithContext(_a0 context.Context, _a1 *ec2.ModifyVpnConnectionInput, _a2 ...request.Option) (*ec2.ModifyVpnConnectionOutput, 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 *ec2.ModifyVpnConnectionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnConnectionInput, ...request.Option) *ec2.ModifyVpnConnectionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnConnectionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpnConnectionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpnTunnelCertificate provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpnTunnelCertificate(_a0 *ec2.ModifyVpnTunnelCertificateInput) (*ec2.ModifyVpnTunnelCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpnTunnelCertificateOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpnTunnelCertificateInput) *ec2.ModifyVpnTunnelCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnTunnelCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpnTunnelCertificateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpnTunnelCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpnTunnelCertificateRequest(_a0 *ec2.ModifyVpnTunnelCertificateInput) (*request.Request, *ec2.ModifyVpnTunnelCertificateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpnTunnelCertificateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpnTunnelCertificateOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpnTunnelCertificateInput) *ec2.ModifyVpnTunnelCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpnTunnelCertificateOutput)
		}
	}

	return r0, r1
}

// ModifyVpnTunnelCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpnTunnelCertificateWithContext(_a0 context.Context, _a1 *ec2.ModifyVpnTunnelCertificateInput, _a2 ...request.Option) (*ec2.ModifyVpnTunnelCertificateOutput, 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 *ec2.ModifyVpnTunnelCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnTunnelCertificateInput, ...request.Option) *ec2.ModifyVpnTunnelCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnTunnelCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpnTunnelCertificateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpnTunnelOptions provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpnTunnelOptions(_a0 *ec2.ModifyVpnTunnelOptionsInput) (*ec2.ModifyVpnTunnelOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ModifyVpnTunnelOptionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpnTunnelOptionsInput) *ec2.ModifyVpnTunnelOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnTunnelOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpnTunnelOptionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyVpnTunnelOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ModifyVpnTunnelOptionsRequest(_a0 *ec2.ModifyVpnTunnelOptionsInput) (*request.Request, *ec2.ModifyVpnTunnelOptionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ModifyVpnTunnelOptionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ModifyVpnTunnelOptionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.ModifyVpnTunnelOptionsInput) *ec2.ModifyVpnTunnelOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ModifyVpnTunnelOptionsOutput)
		}
	}

	return r0, r1
}

// ModifyVpnTunnelOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ModifyVpnTunnelOptionsWithContext(_a0 context.Context, _a1 *ec2.ModifyVpnTunnelOptionsInput, _a2 ...request.Option) (*ec2.ModifyVpnTunnelOptionsOutput, 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 *ec2.ModifyVpnTunnelOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnTunnelOptionsInput, ...request.Option) *ec2.ModifyVpnTunnelOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnTunnelOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpnTunnelOptionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MonitorInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) MonitorInstances(_a0 *ec2.MonitorInstancesInput) (*ec2.MonitorInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.MonitorInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.MonitorInstancesInput) *ec2.MonitorInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.MonitorInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.MonitorInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MonitorInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) MonitorInstancesRequest(_a0 *ec2.MonitorInstancesInput) (*request.Request, *ec2.MonitorInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.MonitorInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.MonitorInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.MonitorInstancesInput) *ec2.MonitorInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.MonitorInstancesOutput)
		}
	}

	return r0, r1
}

// MonitorInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) MonitorInstancesWithContext(_a0 context.Context, _a1 *ec2.MonitorInstancesInput, _a2 ...request.Option) (*ec2.MonitorInstancesOutput, 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 *ec2.MonitorInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MonitorInstancesInput, ...request.Option) *ec2.MonitorInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.MonitorInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.MonitorInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MoveAddressToVpc provides a mock function with given fields: _a0
func (_m *MockFakeEC2) MoveAddressToVpc(_a0 *ec2.MoveAddressToVpcInput) (*ec2.MoveAddressToVpcOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.MoveAddressToVpcOutput
	if rf, ok := ret.Get(0).(func(*ec2.MoveAddressToVpcInput) *ec2.MoveAddressToVpcOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.MoveAddressToVpcOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.MoveAddressToVpcInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MoveAddressToVpcRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) MoveAddressToVpcRequest(_a0 *ec2.MoveAddressToVpcInput) (*request.Request, *ec2.MoveAddressToVpcOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.MoveAddressToVpcInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.MoveAddressToVpcOutput
	if rf, ok := ret.Get(1).(func(*ec2.MoveAddressToVpcInput) *ec2.MoveAddressToVpcOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.MoveAddressToVpcOutput)
		}
	}

	return r0, r1
}

// MoveAddressToVpcWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) MoveAddressToVpcWithContext(_a0 context.Context, _a1 *ec2.MoveAddressToVpcInput, _a2 ...request.Option) (*ec2.MoveAddressToVpcOutput, 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 *ec2.MoveAddressToVpcOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MoveAddressToVpcInput, ...request.Option) *ec2.MoveAddressToVpcOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.MoveAddressToVpcOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.MoveAddressToVpcInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ProvisionByoipCidr provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ProvisionByoipCidr(_a0 *ec2.ProvisionByoipCidrInput) (*ec2.ProvisionByoipCidrOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ProvisionByoipCidrOutput
	if rf, ok := ret.Get(0).(func(*ec2.ProvisionByoipCidrInput) *ec2.ProvisionByoipCidrOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ProvisionByoipCidrOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ProvisionByoipCidrInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ProvisionByoipCidrRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ProvisionByoipCidrRequest(_a0 *ec2.ProvisionByoipCidrInput) (*request.Request, *ec2.ProvisionByoipCidrOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ProvisionByoipCidrInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ProvisionByoipCidrOutput
	if rf, ok := ret.Get(1).(func(*ec2.ProvisionByoipCidrInput) *ec2.ProvisionByoipCidrOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ProvisionByoipCidrOutput)
		}
	}

	return r0, r1
}

// ProvisionByoipCidrWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ProvisionByoipCidrWithContext(_a0 context.Context, _a1 *ec2.ProvisionByoipCidrInput, _a2 ...request.Option) (*ec2.ProvisionByoipCidrOutput, 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 *ec2.ProvisionByoipCidrOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionByoipCidrInput, ...request.Option) *ec2.ProvisionByoipCidrOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ProvisionByoipCidrOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ProvisionByoipCidrInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PurchaseHostReservation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) PurchaseHostReservation(_a0 *ec2.PurchaseHostReservationInput) (*ec2.PurchaseHostReservationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.PurchaseHostReservationOutput
	if rf, ok := ret.Get(0).(func(*ec2.PurchaseHostReservationInput) *ec2.PurchaseHostReservationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseHostReservationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.PurchaseHostReservationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PurchaseHostReservationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) PurchaseHostReservationRequest(_a0 *ec2.PurchaseHostReservationInput) (*request.Request, *ec2.PurchaseHostReservationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.PurchaseHostReservationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.PurchaseHostReservationOutput
	if rf, ok := ret.Get(1).(func(*ec2.PurchaseHostReservationInput) *ec2.PurchaseHostReservationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.PurchaseHostReservationOutput)
		}
	}

	return r0, r1
}

// PurchaseHostReservationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) PurchaseHostReservationWithContext(_a0 context.Context, _a1 *ec2.PurchaseHostReservationInput, _a2 ...request.Option) (*ec2.PurchaseHostReservationOutput, 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 *ec2.PurchaseHostReservationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseHostReservationInput, ...request.Option) *ec2.PurchaseHostReservationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseHostReservationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.PurchaseHostReservationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PurchaseReservedInstancesOffering provides a mock function with given fields: _a0
func (_m *MockFakeEC2) PurchaseReservedInstancesOffering(_a0 *ec2.PurchaseReservedInstancesOfferingInput) (*ec2.PurchaseReservedInstancesOfferingOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.PurchaseReservedInstancesOfferingOutput
	if rf, ok := ret.Get(0).(func(*ec2.PurchaseReservedInstancesOfferingInput) *ec2.PurchaseReservedInstancesOfferingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseReservedInstancesOfferingOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.PurchaseReservedInstancesOfferingInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PurchaseReservedInstancesOfferingRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) PurchaseReservedInstancesOfferingRequest(_a0 *ec2.PurchaseReservedInstancesOfferingInput) (*request.Request, *ec2.PurchaseReservedInstancesOfferingOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.PurchaseReservedInstancesOfferingInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.PurchaseReservedInstancesOfferingOutput
	if rf, ok := ret.Get(1).(func(*ec2.PurchaseReservedInstancesOfferingInput) *ec2.PurchaseReservedInstancesOfferingOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.PurchaseReservedInstancesOfferingOutput)
		}
	}

	return r0, r1
}

// PurchaseReservedInstancesOfferingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) PurchaseReservedInstancesOfferingWithContext(_a0 context.Context, _a1 *ec2.PurchaseReservedInstancesOfferingInput, _a2 ...request.Option) (*ec2.PurchaseReservedInstancesOfferingOutput, 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 *ec2.PurchaseReservedInstancesOfferingOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseReservedInstancesOfferingInput, ...request.Option) *ec2.PurchaseReservedInstancesOfferingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseReservedInstancesOfferingOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.PurchaseReservedInstancesOfferingInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PurchaseScheduledInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) PurchaseScheduledInstances(_a0 *ec2.PurchaseScheduledInstancesInput) (*ec2.PurchaseScheduledInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.PurchaseScheduledInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.PurchaseScheduledInstancesInput) *ec2.PurchaseScheduledInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseScheduledInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.PurchaseScheduledInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PurchaseScheduledInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) PurchaseScheduledInstancesRequest(_a0 *ec2.PurchaseScheduledInstancesInput) (*request.Request, *ec2.PurchaseScheduledInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.PurchaseScheduledInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.PurchaseScheduledInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.PurchaseScheduledInstancesInput) *ec2.PurchaseScheduledInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.PurchaseScheduledInstancesOutput)
		}
	}

	return r0, r1
}

// PurchaseScheduledInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) PurchaseScheduledInstancesWithContext(_a0 context.Context, _a1 *ec2.PurchaseScheduledInstancesInput, _a2 ...request.Option) (*ec2.PurchaseScheduledInstancesOutput, 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 *ec2.PurchaseScheduledInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseScheduledInstancesInput, ...request.Option) *ec2.PurchaseScheduledInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseScheduledInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.PurchaseScheduledInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RebootInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RebootInstances(_a0 *ec2.RebootInstancesInput) (*ec2.RebootInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RebootInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.RebootInstancesInput) *ec2.RebootInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RebootInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RebootInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RebootInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RebootInstancesRequest(_a0 *ec2.RebootInstancesInput) (*request.Request, *ec2.RebootInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RebootInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RebootInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.RebootInstancesInput) *ec2.RebootInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RebootInstancesOutput)
		}
	}

	return r0, r1
}

// RebootInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RebootInstancesWithContext(_a0 context.Context, _a1 *ec2.RebootInstancesInput, _a2 ...request.Option) (*ec2.RebootInstancesOutput, 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 *ec2.RebootInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RebootInstancesInput, ...request.Option) *ec2.RebootInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RebootInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RebootInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterImage provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RegisterImage(_a0 *ec2.RegisterImageInput) (*ec2.RegisterImageOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RegisterImageOutput
	if rf, ok := ret.Get(0).(func(*ec2.RegisterImageInput) *ec2.RegisterImageOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RegisterImageInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterImageRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RegisterImageRequest(_a0 *ec2.RegisterImageInput) (*request.Request, *ec2.RegisterImageOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RegisterImageInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RegisterImageOutput
	if rf, ok := ret.Get(1).(func(*ec2.RegisterImageInput) *ec2.RegisterImageOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RegisterImageOutput)
		}
	}

	return r0, r1
}

// RegisterImageWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RegisterImageWithContext(_a0 context.Context, _a1 *ec2.RegisterImageInput, _a2 ...request.Option) (*ec2.RegisterImageOutput, 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 *ec2.RegisterImageOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterImageInput, ...request.Option) *ec2.RegisterImageOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterImageOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RegisterImageInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterInstanceEventNotificationAttributes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RegisterInstanceEventNotificationAttributes(_a0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RegisterInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(0).(func(*ec2.RegisterInstanceEventNotificationAttributesInput) *ec2.RegisterInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterInstanceEventNotificationAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RegisterInstanceEventNotificationAttributesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterInstanceEventNotificationAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RegisterInstanceEventNotificationAttributesRequest(_a0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.RegisterInstanceEventNotificationAttributesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RegisterInstanceEventNotificationAttributesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RegisterInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(1).(func(*ec2.RegisterInstanceEventNotificationAttributesInput) *ec2.RegisterInstanceEventNotificationAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RegisterInstanceEventNotificationAttributesOutput)
		}
	}

	return r0, r1
}

// RegisterInstanceEventNotificationAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RegisterInstanceEventNotificationAttributesWithContext(_a0 context.Context, _a1 *ec2.RegisterInstanceEventNotificationAttributesInput, _a2 ...request.Option) (*ec2.RegisterInstanceEventNotificationAttributesOutput, 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 *ec2.RegisterInstanceEventNotificationAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterInstanceEventNotificationAttributesInput, ...request.Option) *ec2.RegisterInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterInstanceEventNotificationAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RegisterInstanceEventNotificationAttributesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterTransitGatewayMulticastGroupMembers provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RegisterTransitGatewayMulticastGroupMembers(_a0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RegisterTransitGatewayMulticastGroupMembersOutput
	if rf, ok := ret.Get(0).(func(*ec2.RegisterTransitGatewayMulticastGroupMembersInput) *ec2.RegisterTransitGatewayMulticastGroupMembersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RegisterTransitGatewayMulticastGroupMembersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterTransitGatewayMulticastGroupMembersRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RegisterTransitGatewayMulticastGroupMembersRequest(_a0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupMembersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RegisterTransitGatewayMulticastGroupMembersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RegisterTransitGatewayMulticastGroupMembersOutput
	if rf, ok := ret.Get(1).(func(*ec2.RegisterTransitGatewayMulticastGroupMembersInput) *ec2.RegisterTransitGatewayMulticastGroupMembersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
		}
	}

	return r0, r1
}

// RegisterTransitGatewayMulticastGroupMembersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RegisterTransitGatewayMulticastGroupMembersWithContext(_a0 context.Context, _a1 *ec2.RegisterTransitGatewayMulticastGroupMembersInput, _a2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, 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 *ec2.RegisterTransitGatewayMulticastGroupMembersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupMembersInput, ...request.Option) *ec2.RegisterTransitGatewayMulticastGroupMembersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupMembersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterTransitGatewayMulticastGroupSources provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RegisterTransitGatewayMulticastGroupSources(_a0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput
	if rf, ok := ret.Get(0).(func(*ec2.RegisterTransitGatewayMulticastGroupSourcesInput) *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RegisterTransitGatewayMulticastGroupSourcesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterTransitGatewayMulticastGroupSourcesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RegisterTransitGatewayMulticastGroupSourcesRequest(_a0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RegisterTransitGatewayMulticastGroupSourcesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput
	if rf, ok := ret.Get(1).(func(*ec2.RegisterTransitGatewayMulticastGroupSourcesInput) *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
		}
	}

	return r0, r1
}

// RegisterTransitGatewayMulticastGroupSourcesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RegisterTransitGatewayMulticastGroupSourcesWithContext(_a0 context.Context, _a1 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, _a2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, 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 *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, ...request.Option) *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectTransitGatewayMulticastDomainAssociations provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectTransitGatewayMulticastDomainAssociations(_a0 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(0).(func(*ec2.RejectTransitGatewayMulticastDomainAssociationsInput) *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RejectTransitGatewayMulticastDomainAssociationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectTransitGatewayMulticastDomainAssociationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectTransitGatewayMulticastDomainAssociationsRequest(_a0 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RejectTransitGatewayMulticastDomainAssociationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(1).(func(*ec2.RejectTransitGatewayMulticastDomainAssociationsInput) *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	return r0, r1
}

// RejectTransitGatewayMulticastDomainAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RejectTransitGatewayMulticastDomainAssociationsWithContext(_a0 context.Context, _a1 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, _a2 ...request.Option) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, 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 *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, ...request.Option) *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectTransitGatewayPeeringAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectTransitGatewayPeeringAttachment(_a0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RejectTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.RejectTransitGatewayPeeringAttachmentInput) *ec2.RejectTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RejectTransitGatewayPeeringAttachmentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectTransitGatewayPeeringAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectTransitGatewayPeeringAttachmentRequest(_a0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayPeeringAttachmentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RejectTransitGatewayPeeringAttachmentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RejectTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.RejectTransitGatewayPeeringAttachmentInput) *ec2.RejectTransitGatewayPeeringAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
		}
	}

	return r0, r1
}

// RejectTransitGatewayPeeringAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RejectTransitGatewayPeeringAttachmentWithContext(_a0 context.Context, _a1 *ec2.RejectTransitGatewayPeeringAttachmentInput, _a2 ...request.Option) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, 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 *ec2.RejectTransitGatewayPeeringAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayPeeringAttachmentInput, ...request.Option) *ec2.RejectTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectTransitGatewayPeeringAttachmentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectTransitGatewayVpcAttachment provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectTransitGatewayVpcAttachment(_a0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RejectTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(*ec2.RejectTransitGatewayVpcAttachmentInput) *ec2.RejectTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayVpcAttachmentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RejectTransitGatewayVpcAttachmentInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectTransitGatewayVpcAttachmentRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectTransitGatewayVpcAttachmentRequest(_a0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayVpcAttachmentOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RejectTransitGatewayVpcAttachmentInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RejectTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(1).(func(*ec2.RejectTransitGatewayVpcAttachmentInput) *ec2.RejectTransitGatewayVpcAttachmentOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RejectTransitGatewayVpcAttachmentOutput)
		}
	}

	return r0, r1
}

// RejectTransitGatewayVpcAttachmentWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RejectTransitGatewayVpcAttachmentWithContext(_a0 context.Context, _a1 *ec2.RejectTransitGatewayVpcAttachmentInput, _a2 ...request.Option) (*ec2.RejectTransitGatewayVpcAttachmentOutput, 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 *ec2.RejectTransitGatewayVpcAttachmentOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayVpcAttachmentInput, ...request.Option) *ec2.RejectTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayVpcAttachmentOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectTransitGatewayVpcAttachmentInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectVpcEndpointConnections provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectVpcEndpointConnections(_a0 *ec2.RejectVpcEndpointConnectionsInput) (*ec2.RejectVpcEndpointConnectionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RejectVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.RejectVpcEndpointConnectionsInput) *ec2.RejectVpcEndpointConnectionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectVpcEndpointConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RejectVpcEndpointConnectionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectVpcEndpointConnectionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectVpcEndpointConnectionsRequest(_a0 *ec2.RejectVpcEndpointConnectionsInput) (*request.Request, *ec2.RejectVpcEndpointConnectionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RejectVpcEndpointConnectionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RejectVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.RejectVpcEndpointConnectionsInput) *ec2.RejectVpcEndpointConnectionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RejectVpcEndpointConnectionsOutput)
		}
	}

	return r0, r1
}

// RejectVpcEndpointConnectionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RejectVpcEndpointConnectionsWithContext(_a0 context.Context, _a1 *ec2.RejectVpcEndpointConnectionsInput, _a2 ...request.Option) (*ec2.RejectVpcEndpointConnectionsOutput, 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 *ec2.RejectVpcEndpointConnectionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectVpcEndpointConnectionsInput, ...request.Option) *ec2.RejectVpcEndpointConnectionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectVpcEndpointConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectVpcEndpointConnectionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectVpcPeeringConnection provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectVpcPeeringConnection(_a0 *ec2.RejectVpcPeeringConnectionInput) (*ec2.RejectVpcPeeringConnectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RejectVpcPeeringConnectionOutput
	if rf, ok := ret.Get(0).(func(*ec2.RejectVpcPeeringConnectionInput) *ec2.RejectVpcPeeringConnectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectVpcPeeringConnectionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RejectVpcPeeringConnectionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RejectVpcPeeringConnectionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RejectVpcPeeringConnectionRequest(_a0 *ec2.RejectVpcPeeringConnectionInput) (*request.Request, *ec2.RejectVpcPeeringConnectionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RejectVpcPeeringConnectionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RejectVpcPeeringConnectionOutput
	if rf, ok := ret.Get(1).(func(*ec2.RejectVpcPeeringConnectionInput) *ec2.RejectVpcPeeringConnectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RejectVpcPeeringConnectionOutput)
		}
	}

	return r0, r1
}

// RejectVpcPeeringConnectionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RejectVpcPeeringConnectionWithContext(_a0 context.Context, _a1 *ec2.RejectVpcPeeringConnectionInput, _a2 ...request.Option) (*ec2.RejectVpcPeeringConnectionOutput, 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 *ec2.RejectVpcPeeringConnectionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectVpcPeeringConnectionInput, ...request.Option) *ec2.RejectVpcPeeringConnectionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectVpcPeeringConnectionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectVpcPeeringConnectionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReleaseAddress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReleaseAddress(_a0 *ec2.ReleaseAddressInput) (*ec2.ReleaseAddressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReleaseAddressOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReleaseAddressInput) *ec2.ReleaseAddressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReleaseAddressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReleaseAddressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReleaseAddressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReleaseAddressRequest(_a0 *ec2.ReleaseAddressInput) (*request.Request, *ec2.ReleaseAddressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReleaseAddressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReleaseAddressOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReleaseAddressInput) *ec2.ReleaseAddressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReleaseAddressOutput)
		}
	}

	return r0, r1
}

// ReleaseAddressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReleaseAddressWithContext(_a0 context.Context, _a1 *ec2.ReleaseAddressInput, _a2 ...request.Option) (*ec2.ReleaseAddressOutput, 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 *ec2.ReleaseAddressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReleaseAddressInput, ...request.Option) *ec2.ReleaseAddressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReleaseAddressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReleaseAddressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReleaseHosts provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReleaseHosts(_a0 *ec2.ReleaseHostsInput) (*ec2.ReleaseHostsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReleaseHostsOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReleaseHostsInput) *ec2.ReleaseHostsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReleaseHostsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReleaseHostsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReleaseHostsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReleaseHostsRequest(_a0 *ec2.ReleaseHostsInput) (*request.Request, *ec2.ReleaseHostsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReleaseHostsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReleaseHostsOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReleaseHostsInput) *ec2.ReleaseHostsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReleaseHostsOutput)
		}
	}

	return r0, r1
}

// ReleaseHostsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReleaseHostsWithContext(_a0 context.Context, _a1 *ec2.ReleaseHostsInput, _a2 ...request.Option) (*ec2.ReleaseHostsOutput, 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 *ec2.ReleaseHostsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReleaseHostsInput, ...request.Option) *ec2.ReleaseHostsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReleaseHostsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReleaseHostsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceIamInstanceProfileAssociation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceIamInstanceProfileAssociation(_a0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReplaceIamInstanceProfileAssociationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceIamInstanceProfileAssociationInput) *ec2.ReplaceIamInstanceProfileAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceIamInstanceProfileAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceIamInstanceProfileAssociationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceIamInstanceProfileAssociationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceIamInstanceProfileAssociationRequest(_a0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*request.Request, *ec2.ReplaceIamInstanceProfileAssociationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceIamInstanceProfileAssociationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReplaceIamInstanceProfileAssociationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceIamInstanceProfileAssociationInput) *ec2.ReplaceIamInstanceProfileAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReplaceIamInstanceProfileAssociationOutput)
		}
	}

	return r0, r1
}

// ReplaceIamInstanceProfileAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReplaceIamInstanceProfileAssociationWithContext(_a0 context.Context, _a1 *ec2.ReplaceIamInstanceProfileAssociationInput, _a2 ...request.Option) (*ec2.ReplaceIamInstanceProfileAssociationOutput, 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 *ec2.ReplaceIamInstanceProfileAssociationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceIamInstanceProfileAssociationInput, ...request.Option) *ec2.ReplaceIamInstanceProfileAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceIamInstanceProfileAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceIamInstanceProfileAssociationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceNetworkAclAssociation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceNetworkAclAssociation(_a0 *ec2.ReplaceNetworkAclAssociationInput) (*ec2.ReplaceNetworkAclAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReplaceNetworkAclAssociationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceNetworkAclAssociationInput) *ec2.ReplaceNetworkAclAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceNetworkAclAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceNetworkAclAssociationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceNetworkAclAssociationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceNetworkAclAssociationRequest(_a0 *ec2.ReplaceNetworkAclAssociationInput) (*request.Request, *ec2.ReplaceNetworkAclAssociationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceNetworkAclAssociationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReplaceNetworkAclAssociationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceNetworkAclAssociationInput) *ec2.ReplaceNetworkAclAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReplaceNetworkAclAssociationOutput)
		}
	}

	return r0, r1
}

// ReplaceNetworkAclAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReplaceNetworkAclAssociationWithContext(_a0 context.Context, _a1 *ec2.ReplaceNetworkAclAssociationInput, _a2 ...request.Option) (*ec2.ReplaceNetworkAclAssociationOutput, 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 *ec2.ReplaceNetworkAclAssociationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceNetworkAclAssociationInput, ...request.Option) *ec2.ReplaceNetworkAclAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceNetworkAclAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceNetworkAclAssociationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceNetworkAclEntry provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceNetworkAclEntry(_a0 *ec2.ReplaceNetworkAclEntryInput) (*ec2.ReplaceNetworkAclEntryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReplaceNetworkAclEntryOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceNetworkAclEntryInput) *ec2.ReplaceNetworkAclEntryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceNetworkAclEntryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceNetworkAclEntryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceNetworkAclEntryRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceNetworkAclEntryRequest(_a0 *ec2.ReplaceNetworkAclEntryInput) (*request.Request, *ec2.ReplaceNetworkAclEntryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceNetworkAclEntryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReplaceNetworkAclEntryOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceNetworkAclEntryInput) *ec2.ReplaceNetworkAclEntryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReplaceNetworkAclEntryOutput)
		}
	}

	return r0, r1
}

// ReplaceNetworkAclEntryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReplaceNetworkAclEntryWithContext(_a0 context.Context, _a1 *ec2.ReplaceNetworkAclEntryInput, _a2 ...request.Option) (*ec2.ReplaceNetworkAclEntryOutput, 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 *ec2.ReplaceNetworkAclEntryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceNetworkAclEntryInput, ...request.Option) *ec2.ReplaceNetworkAclEntryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceNetworkAclEntryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceNetworkAclEntryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceRoute(_a0 *ec2.ReplaceRouteInput) (*ec2.ReplaceRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReplaceRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceRouteInput) *ec2.ReplaceRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceRouteOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceRouteInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceRouteRequest(_a0 *ec2.ReplaceRouteInput) (*request.Request, *ec2.ReplaceRouteOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceRouteInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReplaceRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceRouteInput) *ec2.ReplaceRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReplaceRouteOutput)
		}
	}

	return r0, r1
}

// ReplaceRouteTableAssociation provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceRouteTableAssociation(_a0 *ec2.ReplaceRouteTableAssociationInput) (*ec2.ReplaceRouteTableAssociationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReplaceRouteTableAssociationOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceRouteTableAssociationInput) *ec2.ReplaceRouteTableAssociationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceRouteTableAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceRouteTableAssociationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceRouteTableAssociationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceRouteTableAssociationRequest(_a0 *ec2.ReplaceRouteTableAssociationInput) (*request.Request, *ec2.ReplaceRouteTableAssociationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceRouteTableAssociationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReplaceRouteTableAssociationOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceRouteTableAssociationInput) *ec2.ReplaceRouteTableAssociationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReplaceRouteTableAssociationOutput)
		}
	}

	return r0, r1
}

// ReplaceRouteTableAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReplaceRouteTableAssociationWithContext(_a0 context.Context, _a1 *ec2.ReplaceRouteTableAssociationInput, _a2 ...request.Option) (*ec2.ReplaceRouteTableAssociationOutput, 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 *ec2.ReplaceRouteTableAssociationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceRouteTableAssociationInput, ...request.Option) *ec2.ReplaceRouteTableAssociationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceRouteTableAssociationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceRouteTableAssociationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReplaceRouteWithContext(_a0 context.Context, _a1 *ec2.ReplaceRouteInput, _a2 ...request.Option) (*ec2.ReplaceRouteOutput, 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 *ec2.ReplaceRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceRouteInput, ...request.Option) *ec2.ReplaceRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceRouteOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceRouteInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceTransitGatewayRoute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceTransitGatewayRoute(_a0 *ec2.ReplaceTransitGatewayRouteInput) (*ec2.ReplaceTransitGatewayRouteOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReplaceTransitGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceTransitGatewayRouteInput) *ec2.ReplaceTransitGatewayRouteOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceTransitGatewayRouteOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceTransitGatewayRouteInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReplaceTransitGatewayRouteRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReplaceTransitGatewayRouteRequest(_a0 *ec2.ReplaceTransitGatewayRouteInput) (*request.Request, *ec2.ReplaceTransitGatewayRouteOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReplaceTransitGatewayRouteInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReplaceTransitGatewayRouteOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReplaceTransitGatewayRouteInput) *ec2.ReplaceTransitGatewayRouteOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReplaceTransitGatewayRouteOutput)
		}
	}

	return r0, r1
}

// ReplaceTransitGatewayRouteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReplaceTransitGatewayRouteWithContext(_a0 context.Context, _a1 *ec2.ReplaceTransitGatewayRouteInput, _a2 ...request.Option) (*ec2.ReplaceTransitGatewayRouteOutput, 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 *ec2.ReplaceTransitGatewayRouteOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceTransitGatewayRouteInput, ...request.Option) *ec2.ReplaceTransitGatewayRouteOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceTransitGatewayRouteOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceTransitGatewayRouteInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReportInstanceStatus provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReportInstanceStatus(_a0 *ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ReportInstanceStatusOutput
	if rf, ok := ret.Get(0).(func(*ec2.ReportInstanceStatusInput) *ec2.ReportInstanceStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReportInstanceStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ReportInstanceStatusInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ReportInstanceStatusRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ReportInstanceStatusRequest(_a0 *ec2.ReportInstanceStatusInput) (*request.Request, *ec2.ReportInstanceStatusOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ReportInstanceStatusInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ReportInstanceStatusOutput
	if rf, ok := ret.Get(1).(func(*ec2.ReportInstanceStatusInput) *ec2.ReportInstanceStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ReportInstanceStatusOutput)
		}
	}

	return r0, r1
}

// ReportInstanceStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ReportInstanceStatusWithContext(_a0 context.Context, _a1 *ec2.ReportInstanceStatusInput, _a2 ...request.Option) (*ec2.ReportInstanceStatusOutput, 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 *ec2.ReportInstanceStatusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReportInstanceStatusInput, ...request.Option) *ec2.ReportInstanceStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReportInstanceStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReportInstanceStatusInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RequestSpotFleet provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RequestSpotFleet(_a0 *ec2.RequestSpotFleetInput) (*ec2.RequestSpotFleetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RequestSpotFleetOutput
	if rf, ok := ret.Get(0).(func(*ec2.RequestSpotFleetInput) *ec2.RequestSpotFleetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RequestSpotFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RequestSpotFleetInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RequestSpotFleetRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RequestSpotFleetRequest(_a0 *ec2.RequestSpotFleetInput) (*request.Request, *ec2.RequestSpotFleetOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RequestSpotFleetInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RequestSpotFleetOutput
	if rf, ok := ret.Get(1).(func(*ec2.RequestSpotFleetInput) *ec2.RequestSpotFleetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RequestSpotFleetOutput)
		}
	}

	return r0, r1
}

// RequestSpotFleetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RequestSpotFleetWithContext(_a0 context.Context, _a1 *ec2.RequestSpotFleetInput, _a2 ...request.Option) (*ec2.RequestSpotFleetOutput, 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 *ec2.RequestSpotFleetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RequestSpotFleetInput, ...request.Option) *ec2.RequestSpotFleetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RequestSpotFleetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RequestSpotFleetInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RequestSpotInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RequestSpotInstances(_a0 *ec2.RequestSpotInstancesInput) (*ec2.RequestSpotInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RequestSpotInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.RequestSpotInstancesInput) *ec2.RequestSpotInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RequestSpotInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RequestSpotInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RequestSpotInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RequestSpotInstancesRequest(_a0 *ec2.RequestSpotInstancesInput) (*request.Request, *ec2.RequestSpotInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RequestSpotInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RequestSpotInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.RequestSpotInstancesInput) *ec2.RequestSpotInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RequestSpotInstancesOutput)
		}
	}

	return r0, r1
}

// RequestSpotInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RequestSpotInstancesWithContext(_a0 context.Context, _a1 *ec2.RequestSpotInstancesInput, _a2 ...request.Option) (*ec2.RequestSpotInstancesOutput, 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 *ec2.RequestSpotInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RequestSpotInstancesInput, ...request.Option) *ec2.RequestSpotInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RequestSpotInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RequestSpotInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetAddressAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetAddressAttribute(_a0 *ec2.ResetAddressAttributeInput) (*ec2.ResetAddressAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ResetAddressAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ResetAddressAttributeInput) *ec2.ResetAddressAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetAddressAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ResetAddressAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetAddressAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetAddressAttributeRequest(_a0 *ec2.ResetAddressAttributeInput) (*request.Request, *ec2.ResetAddressAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ResetAddressAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ResetAddressAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ResetAddressAttributeInput) *ec2.ResetAddressAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ResetAddressAttributeOutput)
		}
	}

	return r0, r1
}

// ResetAddressAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ResetAddressAttributeWithContext(_a0 context.Context, _a1 *ec2.ResetAddressAttributeInput, _a2 ...request.Option) (*ec2.ResetAddressAttributeOutput, 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 *ec2.ResetAddressAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetAddressAttributeInput, ...request.Option) *ec2.ResetAddressAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetAddressAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetAddressAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetEbsDefaultKmsKeyId provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetEbsDefaultKmsKeyId(_a0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ResetEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(0).(func(*ec2.ResetEbsDefaultKmsKeyIdInput) *ec2.ResetEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetEbsDefaultKmsKeyIdOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ResetEbsDefaultKmsKeyIdInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetEbsDefaultKmsKeyIdRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetEbsDefaultKmsKeyIdRequest(_a0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ResetEbsDefaultKmsKeyIdOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ResetEbsDefaultKmsKeyIdInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ResetEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(1).(func(*ec2.ResetEbsDefaultKmsKeyIdInput) *ec2.ResetEbsDefaultKmsKeyIdOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ResetEbsDefaultKmsKeyIdOutput)
		}
	}

	return r0, r1
}

// ResetEbsDefaultKmsKeyIdWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ResetEbsDefaultKmsKeyIdWithContext(_a0 context.Context, _a1 *ec2.ResetEbsDefaultKmsKeyIdInput, _a2 ...request.Option) (*ec2.ResetEbsDefaultKmsKeyIdOutput, 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 *ec2.ResetEbsDefaultKmsKeyIdOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetEbsDefaultKmsKeyIdInput, ...request.Option) *ec2.ResetEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetEbsDefaultKmsKeyIdOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetEbsDefaultKmsKeyIdInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetFpgaImageAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetFpgaImageAttribute(_a0 *ec2.ResetFpgaImageAttributeInput) (*ec2.ResetFpgaImageAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ResetFpgaImageAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ResetFpgaImageAttributeInput) *ec2.ResetFpgaImageAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetFpgaImageAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ResetFpgaImageAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetFpgaImageAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetFpgaImageAttributeRequest(_a0 *ec2.ResetFpgaImageAttributeInput) (*request.Request, *ec2.ResetFpgaImageAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ResetFpgaImageAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ResetFpgaImageAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ResetFpgaImageAttributeInput) *ec2.ResetFpgaImageAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ResetFpgaImageAttributeOutput)
		}
	}

	return r0, r1
}

// ResetFpgaImageAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ResetFpgaImageAttributeWithContext(_a0 context.Context, _a1 *ec2.ResetFpgaImageAttributeInput, _a2 ...request.Option) (*ec2.ResetFpgaImageAttributeOutput, 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 *ec2.ResetFpgaImageAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetFpgaImageAttributeInput, ...request.Option) *ec2.ResetFpgaImageAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetFpgaImageAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetFpgaImageAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetImageAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetImageAttribute(_a0 *ec2.ResetImageAttributeInput) (*ec2.ResetImageAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ResetImageAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ResetImageAttributeInput) *ec2.ResetImageAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetImageAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ResetImageAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetImageAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetImageAttributeRequest(_a0 *ec2.ResetImageAttributeInput) (*request.Request, *ec2.ResetImageAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ResetImageAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ResetImageAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ResetImageAttributeInput) *ec2.ResetImageAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ResetImageAttributeOutput)
		}
	}

	return r0, r1
}

// ResetImageAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ResetImageAttributeWithContext(_a0 context.Context, _a1 *ec2.ResetImageAttributeInput, _a2 ...request.Option) (*ec2.ResetImageAttributeOutput, 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 *ec2.ResetImageAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetImageAttributeInput, ...request.Option) *ec2.ResetImageAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetImageAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetImageAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetInstanceAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetInstanceAttribute(_a0 *ec2.ResetInstanceAttributeInput) (*ec2.ResetInstanceAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ResetInstanceAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ResetInstanceAttributeInput) *ec2.ResetInstanceAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetInstanceAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ResetInstanceAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetInstanceAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetInstanceAttributeRequest(_a0 *ec2.ResetInstanceAttributeInput) (*request.Request, *ec2.ResetInstanceAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ResetInstanceAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ResetInstanceAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ResetInstanceAttributeInput) *ec2.ResetInstanceAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ResetInstanceAttributeOutput)
		}
	}

	return r0, r1
}

// ResetInstanceAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ResetInstanceAttributeWithContext(_a0 context.Context, _a1 *ec2.ResetInstanceAttributeInput, _a2 ...request.Option) (*ec2.ResetInstanceAttributeOutput, 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 *ec2.ResetInstanceAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetInstanceAttributeInput, ...request.Option) *ec2.ResetInstanceAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetInstanceAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetInstanceAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetNetworkInterfaceAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetNetworkInterfaceAttribute(_a0 *ec2.ResetNetworkInterfaceAttributeInput) (*ec2.ResetNetworkInterfaceAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ResetNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ResetNetworkInterfaceAttributeInput) *ec2.ResetNetworkInterfaceAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetNetworkInterfaceAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ResetNetworkInterfaceAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetNetworkInterfaceAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetNetworkInterfaceAttributeRequest(_a0 *ec2.ResetNetworkInterfaceAttributeInput) (*request.Request, *ec2.ResetNetworkInterfaceAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ResetNetworkInterfaceAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ResetNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ResetNetworkInterfaceAttributeInput) *ec2.ResetNetworkInterfaceAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ResetNetworkInterfaceAttributeOutput)
		}
	}

	return r0, r1
}

// ResetNetworkInterfaceAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ResetNetworkInterfaceAttributeWithContext(_a0 context.Context, _a1 *ec2.ResetNetworkInterfaceAttributeInput, _a2 ...request.Option) (*ec2.ResetNetworkInterfaceAttributeOutput, 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 *ec2.ResetNetworkInterfaceAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetNetworkInterfaceAttributeInput, ...request.Option) *ec2.ResetNetworkInterfaceAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetNetworkInterfaceAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetNetworkInterfaceAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetSnapshotAttribute provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetSnapshotAttribute(_a0 *ec2.ResetSnapshotAttributeInput) (*ec2.ResetSnapshotAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.ResetSnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(*ec2.ResetSnapshotAttributeInput) *ec2.ResetSnapshotAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetSnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.ResetSnapshotAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetSnapshotAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) ResetSnapshotAttributeRequest(_a0 *ec2.ResetSnapshotAttributeInput) (*request.Request, *ec2.ResetSnapshotAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.ResetSnapshotAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.ResetSnapshotAttributeOutput
	if rf, ok := ret.Get(1).(func(*ec2.ResetSnapshotAttributeInput) *ec2.ResetSnapshotAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.ResetSnapshotAttributeOutput)
		}
	}

	return r0, r1
}

// ResetSnapshotAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) ResetSnapshotAttributeWithContext(_a0 context.Context, _a1 *ec2.ResetSnapshotAttributeInput, _a2 ...request.Option) (*ec2.ResetSnapshotAttributeOutput, 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 *ec2.ResetSnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetSnapshotAttributeInput, ...request.Option) *ec2.ResetSnapshotAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetSnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetSnapshotAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreAddressToClassic provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RestoreAddressToClassic(_a0 *ec2.RestoreAddressToClassicInput) (*ec2.RestoreAddressToClassicOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RestoreAddressToClassicOutput
	if rf, ok := ret.Get(0).(func(*ec2.RestoreAddressToClassicInput) *ec2.RestoreAddressToClassicOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreAddressToClassicOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RestoreAddressToClassicInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreAddressToClassicRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RestoreAddressToClassicRequest(_a0 *ec2.RestoreAddressToClassicInput) (*request.Request, *ec2.RestoreAddressToClassicOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RestoreAddressToClassicInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RestoreAddressToClassicOutput
	if rf, ok := ret.Get(1).(func(*ec2.RestoreAddressToClassicInput) *ec2.RestoreAddressToClassicOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RestoreAddressToClassicOutput)
		}
	}

	return r0, r1
}

// RestoreAddressToClassicWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RestoreAddressToClassicWithContext(_a0 context.Context, _a1 *ec2.RestoreAddressToClassicInput, _a2 ...request.Option) (*ec2.RestoreAddressToClassicOutput, 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 *ec2.RestoreAddressToClassicOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreAddressToClassicInput, ...request.Option) *ec2.RestoreAddressToClassicOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreAddressToClassicOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreAddressToClassicInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreManagedPrefixListVersion provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RestoreManagedPrefixListVersion(_a0 *ec2.RestoreManagedPrefixListVersionInput) (*ec2.RestoreManagedPrefixListVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RestoreManagedPrefixListVersionOutput
	if rf, ok := ret.Get(0).(func(*ec2.RestoreManagedPrefixListVersionInput) *ec2.RestoreManagedPrefixListVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreManagedPrefixListVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RestoreManagedPrefixListVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreManagedPrefixListVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RestoreManagedPrefixListVersionRequest(_a0 *ec2.RestoreManagedPrefixListVersionInput) (*request.Request, *ec2.RestoreManagedPrefixListVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RestoreManagedPrefixListVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RestoreManagedPrefixListVersionOutput
	if rf, ok := ret.Get(1).(func(*ec2.RestoreManagedPrefixListVersionInput) *ec2.RestoreManagedPrefixListVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RestoreManagedPrefixListVersionOutput)
		}
	}

	return r0, r1
}

// RestoreManagedPrefixListVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RestoreManagedPrefixListVersionWithContext(_a0 context.Context, _a1 *ec2.RestoreManagedPrefixListVersionInput, _a2 ...request.Option) (*ec2.RestoreManagedPrefixListVersionOutput, 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 *ec2.RestoreManagedPrefixListVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreManagedPrefixListVersionInput, ...request.Option) *ec2.RestoreManagedPrefixListVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreManagedPrefixListVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreManagedPrefixListVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RevokeClientVpnIngress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RevokeClientVpnIngress(_a0 *ec2.RevokeClientVpnIngressInput) (*ec2.RevokeClientVpnIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RevokeClientVpnIngressOutput
	if rf, ok := ret.Get(0).(func(*ec2.RevokeClientVpnIngressInput) *ec2.RevokeClientVpnIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeClientVpnIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RevokeClientVpnIngressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RevokeClientVpnIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RevokeClientVpnIngressRequest(_a0 *ec2.RevokeClientVpnIngressInput) (*request.Request, *ec2.RevokeClientVpnIngressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RevokeClientVpnIngressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RevokeClientVpnIngressOutput
	if rf, ok := ret.Get(1).(func(*ec2.RevokeClientVpnIngressInput) *ec2.RevokeClientVpnIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RevokeClientVpnIngressOutput)
		}
	}

	return r0, r1
}

// RevokeClientVpnIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RevokeClientVpnIngressWithContext(_a0 context.Context, _a1 *ec2.RevokeClientVpnIngressInput, _a2 ...request.Option) (*ec2.RevokeClientVpnIngressOutput, 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 *ec2.RevokeClientVpnIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeClientVpnIngressInput, ...request.Option) *ec2.RevokeClientVpnIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeClientVpnIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RevokeClientVpnIngressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RevokeSecurityGroupEgress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RevokeSecurityGroupEgress(_a0 *ec2.RevokeSecurityGroupEgressInput) (*ec2.RevokeSecurityGroupEgressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RevokeSecurityGroupEgressOutput
	if rf, ok := ret.Get(0).(func(*ec2.RevokeSecurityGroupEgressInput) *ec2.RevokeSecurityGroupEgressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeSecurityGroupEgressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RevokeSecurityGroupEgressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RevokeSecurityGroupEgressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RevokeSecurityGroupEgressRequest(_a0 *ec2.RevokeSecurityGroupEgressInput) (*request.Request, *ec2.RevokeSecurityGroupEgressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RevokeSecurityGroupEgressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RevokeSecurityGroupEgressOutput
	if rf, ok := ret.Get(1).(func(*ec2.RevokeSecurityGroupEgressInput) *ec2.RevokeSecurityGroupEgressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RevokeSecurityGroupEgressOutput)
		}
	}

	return r0, r1
}

// RevokeSecurityGroupEgressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RevokeSecurityGroupEgressWithContext(_a0 context.Context, _a1 *ec2.RevokeSecurityGroupEgressInput, _a2 ...request.Option) (*ec2.RevokeSecurityGroupEgressOutput, 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 *ec2.RevokeSecurityGroupEgressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeSecurityGroupEgressInput, ...request.Option) *ec2.RevokeSecurityGroupEgressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeSecurityGroupEgressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RevokeSecurityGroupEgressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RevokeSecurityGroupIngress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RevokeSecurityGroupIngress(_a0 *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RevokeSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(*ec2.RevokeSecurityGroupIngressInput) *ec2.RevokeSecurityGroupIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeSecurityGroupIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RevokeSecurityGroupIngressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RevokeSecurityGroupIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RevokeSecurityGroupIngressRequest(_a0 *ec2.RevokeSecurityGroupIngressInput) (*request.Request, *ec2.RevokeSecurityGroupIngressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RevokeSecurityGroupIngressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RevokeSecurityGroupIngressOutput
	if rf, ok := ret.Get(1).(func(*ec2.RevokeSecurityGroupIngressInput) *ec2.RevokeSecurityGroupIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RevokeSecurityGroupIngressOutput)
		}
	}

	return r0, r1
}

// RevokeSecurityGroupIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RevokeSecurityGroupIngressWithContext(_a0 context.Context, _a1 *ec2.RevokeSecurityGroupIngressInput, _a2 ...request.Option) (*ec2.RevokeSecurityGroupIngressOutput, 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 *ec2.RevokeSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeSecurityGroupIngressInput, ...request.Option) *ec2.RevokeSecurityGroupIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeSecurityGroupIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RevokeSecurityGroupIngressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RunInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RunInstances(_a0 *ec2.RunInstancesInput) (*ec2.Reservation, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.Reservation
	if rf, ok := ret.Get(0).(func(*ec2.RunInstancesInput) *ec2.Reservation); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.Reservation)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RunInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RunInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RunInstancesRequest(_a0 *ec2.RunInstancesInput) (*request.Request, *ec2.Reservation) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RunInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.Reservation
	if rf, ok := ret.Get(1).(func(*ec2.RunInstancesInput) *ec2.Reservation); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.Reservation)
		}
	}

	return r0, r1
}

// RunInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RunInstancesWithContext(_a0 context.Context, _a1 *ec2.RunInstancesInput, _a2 ...request.Option) (*ec2.Reservation, 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 *ec2.Reservation
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RunInstancesInput, ...request.Option) *ec2.Reservation); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.Reservation)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RunInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RunScheduledInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RunScheduledInstances(_a0 *ec2.RunScheduledInstancesInput) (*ec2.RunScheduledInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.RunScheduledInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.RunScheduledInstancesInput) *ec2.RunScheduledInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RunScheduledInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.RunScheduledInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RunScheduledInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) RunScheduledInstancesRequest(_a0 *ec2.RunScheduledInstancesInput) (*request.Request, *ec2.RunScheduledInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.RunScheduledInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.RunScheduledInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.RunScheduledInstancesInput) *ec2.RunScheduledInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.RunScheduledInstancesOutput)
		}
	}

	return r0, r1
}

// RunScheduledInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) RunScheduledInstancesWithContext(_a0 context.Context, _a1 *ec2.RunScheduledInstancesInput, _a2 ...request.Option) (*ec2.RunScheduledInstancesOutput, 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 *ec2.RunScheduledInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RunScheduledInstancesInput, ...request.Option) *ec2.RunScheduledInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RunScheduledInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RunScheduledInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SearchLocalGatewayRoutes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) SearchLocalGatewayRoutes(_a0 *ec2.SearchLocalGatewayRoutesInput) (*ec2.SearchLocalGatewayRoutesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.SearchLocalGatewayRoutesOutput
	if rf, ok := ret.Get(0).(func(*ec2.SearchLocalGatewayRoutesInput) *ec2.SearchLocalGatewayRoutesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchLocalGatewayRoutesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.SearchLocalGatewayRoutesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SearchLocalGatewayRoutesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) SearchLocalGatewayRoutesPages(_a0 *ec2.SearchLocalGatewayRoutesInput, _a1 func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.SearchLocalGatewayRoutesInput, func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SearchLocalGatewayRoutesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) SearchLocalGatewayRoutesPagesWithContext(_a0 context.Context, _a1 *ec2.SearchLocalGatewayRoutesInput, _a2 func(*ec2.SearchLocalGatewayRoutesOutput, 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, *ec2.SearchLocalGatewayRoutesInput, func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SearchLocalGatewayRoutesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) SearchLocalGatewayRoutesRequest(_a0 *ec2.SearchLocalGatewayRoutesInput) (*request.Request, *ec2.SearchLocalGatewayRoutesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.SearchLocalGatewayRoutesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.SearchLocalGatewayRoutesOutput
	if rf, ok := ret.Get(1).(func(*ec2.SearchLocalGatewayRoutesInput) *ec2.SearchLocalGatewayRoutesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.SearchLocalGatewayRoutesOutput)
		}
	}

	return r0, r1
}

// SearchLocalGatewayRoutesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) SearchLocalGatewayRoutesWithContext(_a0 context.Context, _a1 *ec2.SearchLocalGatewayRoutesInput, _a2 ...request.Option) (*ec2.SearchLocalGatewayRoutesOutput, 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 *ec2.SearchLocalGatewayRoutesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchLocalGatewayRoutesInput, ...request.Option) *ec2.SearchLocalGatewayRoutesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchLocalGatewayRoutesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.SearchLocalGatewayRoutesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SearchTransitGatewayMulticastGroups provides a mock function with given fields: _a0
func (_m *MockFakeEC2) SearchTransitGatewayMulticastGroups(_a0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.SearchTransitGatewayMulticastGroupsOutput
	if rf, ok := ret.Get(0).(func(*ec2.SearchTransitGatewayMulticastGroupsInput) *ec2.SearchTransitGatewayMulticastGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchTransitGatewayMulticastGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.SearchTransitGatewayMulticastGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SearchTransitGatewayMulticastGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeEC2) SearchTransitGatewayMulticastGroupsPages(_a0 *ec2.SearchTransitGatewayMulticastGroupsInput, _a1 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.SearchTransitGatewayMulticastGroupsInput, func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SearchTransitGatewayMulticastGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeEC2) SearchTransitGatewayMulticastGroupsPagesWithContext(_a0 context.Context, _a1 *ec2.SearchTransitGatewayMulticastGroupsInput, _a2 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, 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, *ec2.SearchTransitGatewayMulticastGroupsInput, func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SearchTransitGatewayMulticastGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) SearchTransitGatewayMulticastGroupsRequest(_a0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*request.Request, *ec2.SearchTransitGatewayMulticastGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.SearchTransitGatewayMulticastGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.SearchTransitGatewayMulticastGroupsOutput
	if rf, ok := ret.Get(1).(func(*ec2.SearchTransitGatewayMulticastGroupsInput) *ec2.SearchTransitGatewayMulticastGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.SearchTransitGatewayMulticastGroupsOutput)
		}
	}

	return r0, r1
}

// SearchTransitGatewayMulticastGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) SearchTransitGatewayMulticastGroupsWithContext(_a0 context.Context, _a1 *ec2.SearchTransitGatewayMulticastGroupsInput, _a2 ...request.Option) (*ec2.SearchTransitGatewayMulticastGroupsOutput, 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 *ec2.SearchTransitGatewayMulticastGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchTransitGatewayMulticastGroupsInput, ...request.Option) *ec2.SearchTransitGatewayMulticastGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchTransitGatewayMulticastGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.SearchTransitGatewayMulticastGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SearchTransitGatewayRoutes provides a mock function with given fields: _a0
func (_m *MockFakeEC2) SearchTransitGatewayRoutes(_a0 *ec2.SearchTransitGatewayRoutesInput) (*ec2.SearchTransitGatewayRoutesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.SearchTransitGatewayRoutesOutput
	if rf, ok := ret.Get(0).(func(*ec2.SearchTransitGatewayRoutesInput) *ec2.SearchTransitGatewayRoutesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchTransitGatewayRoutesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.SearchTransitGatewayRoutesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SearchTransitGatewayRoutesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) SearchTransitGatewayRoutesRequest(_a0 *ec2.SearchTransitGatewayRoutesInput) (*request.Request, *ec2.SearchTransitGatewayRoutesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.SearchTransitGatewayRoutesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.SearchTransitGatewayRoutesOutput
	if rf, ok := ret.Get(1).(func(*ec2.SearchTransitGatewayRoutesInput) *ec2.SearchTransitGatewayRoutesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.SearchTransitGatewayRoutesOutput)
		}
	}

	return r0, r1
}

// SearchTransitGatewayRoutesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) SearchTransitGatewayRoutesWithContext(_a0 context.Context, _a1 *ec2.SearchTransitGatewayRoutesInput, _a2 ...request.Option) (*ec2.SearchTransitGatewayRoutesOutput, 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 *ec2.SearchTransitGatewayRoutesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchTransitGatewayRoutesInput, ...request.Option) *ec2.SearchTransitGatewayRoutesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchTransitGatewayRoutesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.SearchTransitGatewayRoutesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SendDiagnosticInterrupt provides a mock function with given fields: _a0
func (_m *MockFakeEC2) SendDiagnosticInterrupt(_a0 *ec2.SendDiagnosticInterruptInput) (*ec2.SendDiagnosticInterruptOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.SendDiagnosticInterruptOutput
	if rf, ok := ret.Get(0).(func(*ec2.SendDiagnosticInterruptInput) *ec2.SendDiagnosticInterruptOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SendDiagnosticInterruptOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.SendDiagnosticInterruptInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SendDiagnosticInterruptRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) SendDiagnosticInterruptRequest(_a0 *ec2.SendDiagnosticInterruptInput) (*request.Request, *ec2.SendDiagnosticInterruptOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.SendDiagnosticInterruptInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.SendDiagnosticInterruptOutput
	if rf, ok := ret.Get(1).(func(*ec2.SendDiagnosticInterruptInput) *ec2.SendDiagnosticInterruptOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.SendDiagnosticInterruptOutput)
		}
	}

	return r0, r1
}

// SendDiagnosticInterruptWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) SendDiagnosticInterruptWithContext(_a0 context.Context, _a1 *ec2.SendDiagnosticInterruptInput, _a2 ...request.Option) (*ec2.SendDiagnosticInterruptOutput, 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 *ec2.SendDiagnosticInterruptOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SendDiagnosticInterruptInput, ...request.Option) *ec2.SendDiagnosticInterruptOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SendDiagnosticInterruptOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.SendDiagnosticInterruptInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) StartInstances(_a0 *ec2.StartInstancesInput) (*ec2.StartInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.StartInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.StartInstancesInput) *ec2.StartInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.StartInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) StartInstancesRequest(_a0 *ec2.StartInstancesInput) (*request.Request, *ec2.StartInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.StartInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.StartInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.StartInstancesInput) *ec2.StartInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.StartInstancesOutput)
		}
	}

	return r0, r1
}

// StartInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) StartInstancesWithContext(_a0 context.Context, _a1 *ec2.StartInstancesInput, _a2 ...request.Option) (*ec2.StartInstancesOutput, 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 *ec2.StartInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartInstancesInput, ...request.Option) *ec2.StartInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StartInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartNetworkInsightsAnalysis provides a mock function with given fields: _a0
func (_m *MockFakeEC2) StartNetworkInsightsAnalysis(_a0 *ec2.StartNetworkInsightsAnalysisInput) (*ec2.StartNetworkInsightsAnalysisOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.StartNetworkInsightsAnalysisOutput
	if rf, ok := ret.Get(0).(func(*ec2.StartNetworkInsightsAnalysisInput) *ec2.StartNetworkInsightsAnalysisOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartNetworkInsightsAnalysisOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.StartNetworkInsightsAnalysisInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartNetworkInsightsAnalysisRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) StartNetworkInsightsAnalysisRequest(_a0 *ec2.StartNetworkInsightsAnalysisInput) (*request.Request, *ec2.StartNetworkInsightsAnalysisOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.StartNetworkInsightsAnalysisInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.StartNetworkInsightsAnalysisOutput
	if rf, ok := ret.Get(1).(func(*ec2.StartNetworkInsightsAnalysisInput) *ec2.StartNetworkInsightsAnalysisOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.StartNetworkInsightsAnalysisOutput)
		}
	}

	return r0, r1
}

// StartNetworkInsightsAnalysisWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) StartNetworkInsightsAnalysisWithContext(_a0 context.Context, _a1 *ec2.StartNetworkInsightsAnalysisInput, _a2 ...request.Option) (*ec2.StartNetworkInsightsAnalysisOutput, 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 *ec2.StartNetworkInsightsAnalysisOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartNetworkInsightsAnalysisInput, ...request.Option) *ec2.StartNetworkInsightsAnalysisOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartNetworkInsightsAnalysisOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StartNetworkInsightsAnalysisInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartVpcEndpointServicePrivateDnsVerification provides a mock function with given fields: _a0
func (_m *MockFakeEC2) StartVpcEndpointServicePrivateDnsVerification(_a0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput
	if rf, ok := ret.Get(0).(func(*ec2.StartVpcEndpointServicePrivateDnsVerificationInput) *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.StartVpcEndpointServicePrivateDnsVerificationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartVpcEndpointServicePrivateDnsVerificationRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) StartVpcEndpointServicePrivateDnsVerificationRequest(_a0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*request.Request, *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.StartVpcEndpointServicePrivateDnsVerificationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput
	if rf, ok := ret.Get(1).(func(*ec2.StartVpcEndpointServicePrivateDnsVerificationInput) *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
		}
	}

	return r0, r1
}

// StartVpcEndpointServicePrivateDnsVerificationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) StartVpcEndpointServicePrivateDnsVerificationWithContext(_a0 context.Context, _a1 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, _a2 ...request.Option) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, 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 *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, ...request.Option) *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) StopInstances(_a0 *ec2.StopInstancesInput) (*ec2.StopInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.StopInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.StopInstancesInput) *ec2.StopInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StopInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.StopInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) StopInstancesRequest(_a0 *ec2.StopInstancesInput) (*request.Request, *ec2.StopInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.StopInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.StopInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.StopInstancesInput) *ec2.StopInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.StopInstancesOutput)
		}
	}

	return r0, r1
}

// StopInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) StopInstancesWithContext(_a0 context.Context, _a1 *ec2.StopInstancesInput, _a2 ...request.Option) (*ec2.StopInstancesOutput, 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 *ec2.StopInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StopInstancesInput, ...request.Option) *ec2.StopInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StopInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StopInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TerminateClientVpnConnections provides a mock function with given fields: _a0
func (_m *MockFakeEC2) TerminateClientVpnConnections(_a0 *ec2.TerminateClientVpnConnectionsInput) (*ec2.TerminateClientVpnConnectionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.TerminateClientVpnConnectionsOutput
	if rf, ok := ret.Get(0).(func(*ec2.TerminateClientVpnConnectionsInput) *ec2.TerminateClientVpnConnectionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.TerminateClientVpnConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.TerminateClientVpnConnectionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TerminateClientVpnConnectionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) TerminateClientVpnConnectionsRequest(_a0 *ec2.TerminateClientVpnConnectionsInput) (*request.Request, *ec2.TerminateClientVpnConnectionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.TerminateClientVpnConnectionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.TerminateClientVpnConnectionsOutput
	if rf, ok := ret.Get(1).(func(*ec2.TerminateClientVpnConnectionsInput) *ec2.TerminateClientVpnConnectionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.TerminateClientVpnConnectionsOutput)
		}
	}

	return r0, r1
}

// TerminateClientVpnConnectionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) TerminateClientVpnConnectionsWithContext(_a0 context.Context, _a1 *ec2.TerminateClientVpnConnectionsInput, _a2 ...request.Option) (*ec2.TerminateClientVpnConnectionsOutput, 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 *ec2.TerminateClientVpnConnectionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.TerminateClientVpnConnectionsInput, ...request.Option) *ec2.TerminateClientVpnConnectionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.TerminateClientVpnConnectionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.TerminateClientVpnConnectionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TerminateInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) TerminateInstances(_a0 *ec2.TerminateInstancesInput) (*ec2.TerminateInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.TerminateInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.TerminateInstancesInput) *ec2.TerminateInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.TerminateInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.TerminateInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TerminateInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) TerminateInstancesRequest(_a0 *ec2.TerminateInstancesInput) (*request.Request, *ec2.TerminateInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.TerminateInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.TerminateInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.TerminateInstancesInput) *ec2.TerminateInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.TerminateInstancesOutput)
		}
	}

	return r0, r1
}

// TerminateInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) TerminateInstancesWithContext(_a0 context.Context, _a1 *ec2.TerminateInstancesInput, _a2 ...request.Option) (*ec2.TerminateInstancesOutput, 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 *ec2.TerminateInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.TerminateInstancesInput, ...request.Option) *ec2.TerminateInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.TerminateInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.TerminateInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UnassignIpv6Addresses provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UnassignIpv6Addresses(_a0 *ec2.UnassignIpv6AddressesInput) (*ec2.UnassignIpv6AddressesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.UnassignIpv6AddressesOutput
	if rf, ok := ret.Get(0).(func(*ec2.UnassignIpv6AddressesInput) *ec2.UnassignIpv6AddressesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnassignIpv6AddressesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.UnassignIpv6AddressesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UnassignIpv6AddressesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UnassignIpv6AddressesRequest(_a0 *ec2.UnassignIpv6AddressesInput) (*request.Request, *ec2.UnassignIpv6AddressesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.UnassignIpv6AddressesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.UnassignIpv6AddressesOutput
	if rf, ok := ret.Get(1).(func(*ec2.UnassignIpv6AddressesInput) *ec2.UnassignIpv6AddressesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.UnassignIpv6AddressesOutput)
		}
	}

	return r0, r1
}

// UnassignIpv6AddressesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) UnassignIpv6AddressesWithContext(_a0 context.Context, _a1 *ec2.UnassignIpv6AddressesInput, _a2 ...request.Option) (*ec2.UnassignIpv6AddressesOutput, 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 *ec2.UnassignIpv6AddressesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnassignIpv6AddressesInput, ...request.Option) *ec2.UnassignIpv6AddressesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnassignIpv6AddressesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UnassignIpv6AddressesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UnassignPrivateIpAddresses provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UnassignPrivateIpAddresses(_a0 *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.UnassignPrivateIpAddressesOutput
	if rf, ok := ret.Get(0).(func(*ec2.UnassignPrivateIpAddressesInput) *ec2.UnassignPrivateIpAddressesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnassignPrivateIpAddressesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.UnassignPrivateIpAddressesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UnassignPrivateIpAddressesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UnassignPrivateIpAddressesRequest(_a0 *ec2.UnassignPrivateIpAddressesInput) (*request.Request, *ec2.UnassignPrivateIpAddressesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.UnassignPrivateIpAddressesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.UnassignPrivateIpAddressesOutput
	if rf, ok := ret.Get(1).(func(*ec2.UnassignPrivateIpAddressesInput) *ec2.UnassignPrivateIpAddressesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.UnassignPrivateIpAddressesOutput)
		}
	}

	return r0, r1
}

// UnassignPrivateIpAddressesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) UnassignPrivateIpAddressesWithContext(_a0 context.Context, _a1 *ec2.UnassignPrivateIpAddressesInput, _a2 ...request.Option) (*ec2.UnassignPrivateIpAddressesOutput, 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 *ec2.UnassignPrivateIpAddressesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnassignPrivateIpAddressesInput, ...request.Option) *ec2.UnassignPrivateIpAddressesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnassignPrivateIpAddressesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UnassignPrivateIpAddressesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UnmonitorInstances provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UnmonitorInstances(_a0 *ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.UnmonitorInstancesOutput
	if rf, ok := ret.Get(0).(func(*ec2.UnmonitorInstancesInput) *ec2.UnmonitorInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnmonitorInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.UnmonitorInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UnmonitorInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UnmonitorInstancesRequest(_a0 *ec2.UnmonitorInstancesInput) (*request.Request, *ec2.UnmonitorInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.UnmonitorInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.UnmonitorInstancesOutput
	if rf, ok := ret.Get(1).(func(*ec2.UnmonitorInstancesInput) *ec2.UnmonitorInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.UnmonitorInstancesOutput)
		}
	}

	return r0, r1
}

// UnmonitorInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) UnmonitorInstancesWithContext(_a0 context.Context, _a1 *ec2.UnmonitorInstancesInput, _a2 ...request.Option) (*ec2.UnmonitorInstancesOutput, 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 *ec2.UnmonitorInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnmonitorInstancesInput, ...request.Option) *ec2.UnmonitorInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnmonitorInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UnmonitorInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSecurityGroupRuleDescriptionsEgress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UpdateSecurityGroupRuleDescriptionsEgress(_a0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput
	if rf, ok := ret.Get(0).(func(*ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSecurityGroupRuleDescriptionsEgressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UpdateSecurityGroupRuleDescriptionsEgressRequest(_a0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput
	if rf, ok := ret.Get(1).(func(*ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
		}
	}

	return r0, r1
}

// UpdateSecurityGroupRuleDescriptionsEgressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) UpdateSecurityGroupRuleDescriptionsEgressWithContext(_a0 context.Context, _a1 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, _a2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, 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 *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, ...request.Option) *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSecurityGroupRuleDescriptionsIngress provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UpdateSecurityGroupRuleDescriptionsIngress(_a0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput
	if rf, ok := ret.Get(0).(func(*ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSecurityGroupRuleDescriptionsIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) UpdateSecurityGroupRuleDescriptionsIngressRequest(_a0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput
	if rf, ok := ret.Get(1).(func(*ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
		}
	}

	return r0, r1
}

// UpdateSecurityGroupRuleDescriptionsIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) UpdateSecurityGroupRuleDescriptionsIngressWithContext(_a0 context.Context, _a1 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, _a2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, 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 *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, ...request.Option) *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilBundleTaskComplete provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilBundleTaskComplete(_a0 *ec2.DescribeBundleTasksInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeBundleTasksInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilBundleTaskCompleteWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilBundleTaskCompleteWithContext(_a0 context.Context, _a1 *ec2.DescribeBundleTasksInput, _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, *ec2.DescribeBundleTasksInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilConversionTaskCancelled provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilConversionTaskCancelled(_a0 *ec2.DescribeConversionTasksInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeConversionTasksInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilConversionTaskCancelledWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilConversionTaskCancelledWithContext(_a0 context.Context, _a1 *ec2.DescribeConversionTasksInput, _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, *ec2.DescribeConversionTasksInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilConversionTaskCompleted provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilConversionTaskCompleted(_a0 *ec2.DescribeConversionTasksInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeConversionTasksInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilConversionTaskCompletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilConversionTaskCompletedWithContext(_a0 context.Context, _a1 *ec2.DescribeConversionTasksInput, _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, *ec2.DescribeConversionTasksInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilConversionTaskDeleted provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilConversionTaskDeleted(_a0 *ec2.DescribeConversionTasksInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeConversionTasksInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilConversionTaskDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilConversionTaskDeletedWithContext(_a0 context.Context, _a1 *ec2.DescribeConversionTasksInput, _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, *ec2.DescribeConversionTasksInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilCustomerGatewayAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilCustomerGatewayAvailable(_a0 *ec2.DescribeCustomerGatewaysInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeCustomerGatewaysInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilCustomerGatewayAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilCustomerGatewayAvailableWithContext(_a0 context.Context, _a1 *ec2.DescribeCustomerGatewaysInput, _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, *ec2.DescribeCustomerGatewaysInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilExportTaskCancelled provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilExportTaskCancelled(_a0 *ec2.DescribeExportTasksInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeExportTasksInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilExportTaskCancelledWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilExportTaskCancelledWithContext(_a0 context.Context, _a1 *ec2.DescribeExportTasksInput, _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, *ec2.DescribeExportTasksInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilExportTaskCompleted provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilExportTaskCompleted(_a0 *ec2.DescribeExportTasksInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeExportTasksInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilExportTaskCompletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilExportTaskCompletedWithContext(_a0 context.Context, _a1 *ec2.DescribeExportTasksInput, _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, *ec2.DescribeExportTasksInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilImageAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilImageAvailable(_a0 *ec2.DescribeImagesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeImagesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilImageAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilImageAvailableWithContext(_a0 context.Context, _a1 *ec2.DescribeImagesInput, _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, *ec2.DescribeImagesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilImageExists provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilImageExists(_a0 *ec2.DescribeImagesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeImagesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilImageExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilImageExistsWithContext(_a0 context.Context, _a1 *ec2.DescribeImagesInput, _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, *ec2.DescribeImagesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceExists provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilInstanceExists(_a0 *ec2.DescribeInstancesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstancesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilInstanceExistsWithContext(_a0 context.Context, _a1 *ec2.DescribeInstancesInput, _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, *ec2.DescribeInstancesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceRunning provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilInstanceRunning(_a0 *ec2.DescribeInstancesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstancesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceRunningWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilInstanceRunningWithContext(_a0 context.Context, _a1 *ec2.DescribeInstancesInput, _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, *ec2.DescribeInstancesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceStatusOk provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilInstanceStatusOk(_a0 *ec2.DescribeInstanceStatusInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstanceStatusInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceStatusOkWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilInstanceStatusOkWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceStatusInput, _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, *ec2.DescribeInstanceStatusInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceStopped provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilInstanceStopped(_a0 *ec2.DescribeInstancesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstancesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceStoppedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilInstanceStoppedWithContext(_a0 context.Context, _a1 *ec2.DescribeInstancesInput, _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, *ec2.DescribeInstancesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceTerminated provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilInstanceTerminated(_a0 *ec2.DescribeInstancesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstancesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceTerminatedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilInstanceTerminatedWithContext(_a0 context.Context, _a1 *ec2.DescribeInstancesInput, _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, *ec2.DescribeInstancesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilKeyPairExists provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilKeyPairExists(_a0 *ec2.DescribeKeyPairsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeKeyPairsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilKeyPairExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilKeyPairExistsWithContext(_a0 context.Context, _a1 *ec2.DescribeKeyPairsInput, _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, *ec2.DescribeKeyPairsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNatGatewayAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilNatGatewayAvailable(_a0 *ec2.DescribeNatGatewaysInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNatGatewaysInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNatGatewayAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilNatGatewayAvailableWithContext(_a0 context.Context, _a1 *ec2.DescribeNatGatewaysInput, _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, *ec2.DescribeNatGatewaysInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNetworkInterfaceAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilNetworkInterfaceAvailable(_a0 *ec2.DescribeNetworkInterfacesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeNetworkInterfacesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNetworkInterfaceAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilNetworkInterfaceAvailableWithContext(_a0 context.Context, _a1 *ec2.DescribeNetworkInterfacesInput, _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, *ec2.DescribeNetworkInterfacesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilPasswordDataAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilPasswordDataAvailable(_a0 *ec2.GetPasswordDataInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.GetPasswordDataInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilPasswordDataAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilPasswordDataAvailableWithContext(_a0 context.Context, _a1 *ec2.GetPasswordDataInput, _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, *ec2.GetPasswordDataInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSecurityGroupExists provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilSecurityGroupExists(_a0 *ec2.DescribeSecurityGroupsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSecurityGroupsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSecurityGroupExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilSecurityGroupExistsWithContext(_a0 context.Context, _a1 *ec2.DescribeSecurityGroupsInput, _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, *ec2.DescribeSecurityGroupsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSnapshotCompleted provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilSnapshotCompleted(_a0 *ec2.DescribeSnapshotsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSnapshotsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSnapshotCompletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilSnapshotCompletedWithContext(_a0 context.Context, _a1 *ec2.DescribeSnapshotsInput, _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, *ec2.DescribeSnapshotsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSpotInstanceRequestFulfilled provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilSpotInstanceRequestFulfilled(_a0 *ec2.DescribeSpotInstanceRequestsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSpotInstanceRequestsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSpotInstanceRequestFulfilledWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilSpotInstanceRequestFulfilledWithContext(_a0 context.Context, _a1 *ec2.DescribeSpotInstanceRequestsInput, _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, *ec2.DescribeSpotInstanceRequestsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSubnetAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilSubnetAvailable(_a0 *ec2.DescribeSubnetsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeSubnetsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSubnetAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilSubnetAvailableWithContext(_a0 context.Context, _a1 *ec2.DescribeSubnetsInput, _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, *ec2.DescribeSubnetsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSystemStatusOk provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilSystemStatusOk(_a0 *ec2.DescribeInstanceStatusInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeInstanceStatusInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilSystemStatusOkWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilSystemStatusOkWithContext(_a0 context.Context, _a1 *ec2.DescribeInstanceStatusInput, _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, *ec2.DescribeInstanceStatusInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVolumeAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVolumeAvailable(_a0 *ec2.DescribeVolumesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVolumeAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVolumeAvailableWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumesInput, _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, *ec2.DescribeVolumesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVolumeDeleted provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVolumeDeleted(_a0 *ec2.DescribeVolumesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVolumeDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVolumeDeletedWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumesInput, _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, *ec2.DescribeVolumesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVolumeInUse provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVolumeInUse(_a0 *ec2.DescribeVolumesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVolumesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVolumeInUseWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVolumeInUseWithContext(_a0 context.Context, _a1 *ec2.DescribeVolumesInput, _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, *ec2.DescribeVolumesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpcAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVpcAvailable(_a0 *ec2.DescribeVpcsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpcAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVpcAvailableWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcsInput, _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, *ec2.DescribeVpcsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpcExists provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVpcExists(_a0 *ec2.DescribeVpcsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpcExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVpcExistsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcsInput, _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, *ec2.DescribeVpcsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpcPeeringConnectionDeleted provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVpcPeeringConnectionDeleted(_a0 *ec2.DescribeVpcPeeringConnectionsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcPeeringConnectionsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpcPeeringConnectionDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVpcPeeringConnectionDeletedWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcPeeringConnectionsInput, _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, *ec2.DescribeVpcPeeringConnectionsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpcPeeringConnectionExists provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVpcPeeringConnectionExists(_a0 *ec2.DescribeVpcPeeringConnectionsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpcPeeringConnectionsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpcPeeringConnectionExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVpcPeeringConnectionExistsWithContext(_a0 context.Context, _a1 *ec2.DescribeVpcPeeringConnectionsInput, _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, *ec2.DescribeVpcPeeringConnectionsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpnConnectionAvailable provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVpnConnectionAvailable(_a0 *ec2.DescribeVpnConnectionsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpnConnectionsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpnConnectionAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVpnConnectionAvailableWithContext(_a0 context.Context, _a1 *ec2.DescribeVpnConnectionsInput, _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, *ec2.DescribeVpnConnectionsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpnConnectionDeleted provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WaitUntilVpnConnectionDeleted(_a0 *ec2.DescribeVpnConnectionsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*ec2.DescribeVpnConnectionsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilVpnConnectionDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WaitUntilVpnConnectionDeletedWithContext(_a0 context.Context, _a1 *ec2.DescribeVpnConnectionsInput, _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, *ec2.DescribeVpnConnectionsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WithdrawByoipCidr provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WithdrawByoipCidr(_a0 *ec2.WithdrawByoipCidrInput) (*ec2.WithdrawByoipCidrOutput, error) {
	ret := _m.Called(_a0)

	var r0 *ec2.WithdrawByoipCidrOutput
	if rf, ok := ret.Get(0).(func(*ec2.WithdrawByoipCidrInput) *ec2.WithdrawByoipCidrOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.WithdrawByoipCidrOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*ec2.WithdrawByoipCidrInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WithdrawByoipCidrRequest provides a mock function with given fields: _a0
func (_m *MockFakeEC2) WithdrawByoipCidrRequest(_a0 *ec2.WithdrawByoipCidrInput) (*request.Request, *ec2.WithdrawByoipCidrOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*ec2.WithdrawByoipCidrInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *ec2.WithdrawByoipCidrOutput
	if rf, ok := ret.Get(1).(func(*ec2.WithdrawByoipCidrInput) *ec2.WithdrawByoipCidrOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ec2.WithdrawByoipCidrOutput)
		}
	}

	return r0, r1
}

// WithdrawByoipCidrWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeEC2) WithdrawByoipCidrWithContext(_a0 context.Context, _a1 *ec2.WithdrawByoipCidrInput, _a2 ...request.Option) (*ec2.WithdrawByoipCidrOutput, 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 *ec2.WithdrawByoipCidrOutput
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.WithdrawByoipCidrInput, ...request.Option) *ec2.WithdrawByoipCidrOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.WithdrawByoipCidrOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *ec2.WithdrawByoipCidrInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}