// Code generated by mockery v2.53.5. DO NOT EDIT.

package mocksv2

import (
	context "context"

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

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

type EC2_Expecter struct {
	mock *mock.Mock
}

func (_m *EC2) EXPECT() *EC2_Expecter {
	return &EC2_Expecter{mock: &_m.Mock}
}

// AcceptAddressTransfer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AcceptAddressTransfer(ctx context.Context, params *ec2.AcceptAddressTransferInput, optFns ...func(*ec2.Options)) (*ec2.AcceptAddressTransferOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AcceptAddressTransfer")
	}

	var r0 *ec2.AcceptAddressTransferOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptAddressTransferInput, ...func(*ec2.Options)) (*ec2.AcceptAddressTransferOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptAddressTransferInput, ...func(*ec2.Options)) *ec2.AcceptAddressTransferOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptAddressTransferOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AcceptAddressTransferInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AcceptAddressTransfer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptAddressTransfer'
type EC2_AcceptAddressTransfer_Call struct {
	*mock.Call
}

// AcceptAddressTransfer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AcceptAddressTransferInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AcceptAddressTransfer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AcceptAddressTransfer_Call {
	return &EC2_AcceptAddressTransfer_Call{Call: _e.mock.On("AcceptAddressTransfer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AcceptAddressTransfer_Call) Run(run func(ctx context.Context, params *ec2.AcceptAddressTransferInput, optFns ...func(*ec2.Options))) *EC2_AcceptAddressTransfer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AcceptAddressTransferInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AcceptAddressTransfer_Call) Return(_a0 *ec2.AcceptAddressTransferOutput, _a1 error) *EC2_AcceptAddressTransfer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AcceptAddressTransfer_Call) RunAndReturn(run func(context.Context, *ec2.AcceptAddressTransferInput, ...func(*ec2.Options)) (*ec2.AcceptAddressTransferOutput, error)) *EC2_AcceptAddressTransfer_Call {
	_c.Call.Return(run)
	return _c
}

// AcceptCapacityReservationBillingOwnership provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AcceptCapacityReservationBillingOwnership(ctx context.Context, params *ec2.AcceptCapacityReservationBillingOwnershipInput, optFns ...func(*ec2.Options)) (*ec2.AcceptCapacityReservationBillingOwnershipOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AcceptCapacityReservationBillingOwnership")
	}

	var r0 *ec2.AcceptCapacityReservationBillingOwnershipOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptCapacityReservationBillingOwnershipInput, ...func(*ec2.Options)) (*ec2.AcceptCapacityReservationBillingOwnershipOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptCapacityReservationBillingOwnershipInput, ...func(*ec2.Options)) *ec2.AcceptCapacityReservationBillingOwnershipOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptCapacityReservationBillingOwnershipOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AcceptCapacityReservationBillingOwnershipInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AcceptCapacityReservationBillingOwnership_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptCapacityReservationBillingOwnership'
type EC2_AcceptCapacityReservationBillingOwnership_Call struct {
	*mock.Call
}

// AcceptCapacityReservationBillingOwnership is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AcceptCapacityReservationBillingOwnershipInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AcceptCapacityReservationBillingOwnership(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AcceptCapacityReservationBillingOwnership_Call {
	return &EC2_AcceptCapacityReservationBillingOwnership_Call{Call: _e.mock.On("AcceptCapacityReservationBillingOwnership",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AcceptCapacityReservationBillingOwnership_Call) Run(run func(ctx context.Context, params *ec2.AcceptCapacityReservationBillingOwnershipInput, optFns ...func(*ec2.Options))) *EC2_AcceptCapacityReservationBillingOwnership_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AcceptCapacityReservationBillingOwnershipInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AcceptCapacityReservationBillingOwnership_Call) Return(_a0 *ec2.AcceptCapacityReservationBillingOwnershipOutput, _a1 error) *EC2_AcceptCapacityReservationBillingOwnership_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AcceptCapacityReservationBillingOwnership_Call) RunAndReturn(run func(context.Context, *ec2.AcceptCapacityReservationBillingOwnershipInput, ...func(*ec2.Options)) (*ec2.AcceptCapacityReservationBillingOwnershipOutput, error)) *EC2_AcceptCapacityReservationBillingOwnership_Call {
	_c.Call.Return(run)
	return _c
}

// AcceptReservedInstancesExchangeQuote provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AcceptReservedInstancesExchangeQuote(ctx context.Context, params *ec2.AcceptReservedInstancesExchangeQuoteInput, optFns ...func(*ec2.Options)) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AcceptReservedInstancesExchangeQuote")
	}

	var r0 *ec2.AcceptReservedInstancesExchangeQuoteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptReservedInstancesExchangeQuoteInput, ...func(*ec2.Options)) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptReservedInstancesExchangeQuoteInput, ...func(*ec2.Options)) *ec2.AcceptReservedInstancesExchangeQuoteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AcceptReservedInstancesExchangeQuoteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AcceptReservedInstancesExchangeQuote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptReservedInstancesExchangeQuote'
type EC2_AcceptReservedInstancesExchangeQuote_Call struct {
	*mock.Call
}

// AcceptReservedInstancesExchangeQuote is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AcceptReservedInstancesExchangeQuoteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AcceptReservedInstancesExchangeQuote(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AcceptReservedInstancesExchangeQuote_Call {
	return &EC2_AcceptReservedInstancesExchangeQuote_Call{Call: _e.mock.On("AcceptReservedInstancesExchangeQuote",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AcceptReservedInstancesExchangeQuote_Call) Run(run func(ctx context.Context, params *ec2.AcceptReservedInstancesExchangeQuoteInput, optFns ...func(*ec2.Options))) *EC2_AcceptReservedInstancesExchangeQuote_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AcceptReservedInstancesExchangeQuoteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AcceptReservedInstancesExchangeQuote_Call) Return(_a0 *ec2.AcceptReservedInstancesExchangeQuoteOutput, _a1 error) *EC2_AcceptReservedInstancesExchangeQuote_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AcceptReservedInstancesExchangeQuote_Call) RunAndReturn(run func(context.Context, *ec2.AcceptReservedInstancesExchangeQuoteInput, ...func(*ec2.Options)) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error)) *EC2_AcceptReservedInstancesExchangeQuote_Call {
	_c.Call.Return(run)
	return _c
}

// AcceptTransitGatewayMulticastDomainAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AcceptTransitGatewayMulticastDomainAssociations(ctx context.Context, params *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AcceptTransitGatewayMulticastDomainAssociations")
	}

	var r0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AcceptTransitGatewayMulticastDomainAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptTransitGatewayMulticastDomainAssociations'
type EC2_AcceptTransitGatewayMulticastDomainAssociations_Call struct {
	*mock.Call
}

// AcceptTransitGatewayMulticastDomainAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AcceptTransitGatewayMulticastDomainAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AcceptTransitGatewayMulticastDomainAssociations_Call {
	return &EC2_AcceptTransitGatewayMulticastDomainAssociations_Call{Call: _e.mock.On("AcceptTransitGatewayMulticastDomainAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AcceptTransitGatewayMulticastDomainAssociations_Call) Run(run func(ctx context.Context, params *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, optFns ...func(*ec2.Options))) *EC2_AcceptTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AcceptTransitGatewayMulticastDomainAssociations_Call) Return(_a0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, _a1 error) *EC2_AcceptTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AcceptTransitGatewayMulticastDomainAssociations_Call) RunAndReturn(run func(context.Context, *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error)) *EC2_AcceptTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// AcceptTransitGatewayPeeringAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AcceptTransitGatewayPeeringAttachment(ctx context.Context, params *ec2.AcceptTransitGatewayPeeringAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AcceptTransitGatewayPeeringAttachment")
	}

	var r0 *ec2.AcceptTransitGatewayPeeringAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) *ec2.AcceptTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AcceptTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AcceptTransitGatewayPeeringAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptTransitGatewayPeeringAttachment'
type EC2_AcceptTransitGatewayPeeringAttachment_Call struct {
	*mock.Call
}

// AcceptTransitGatewayPeeringAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AcceptTransitGatewayPeeringAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AcceptTransitGatewayPeeringAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AcceptTransitGatewayPeeringAttachment_Call {
	return &EC2_AcceptTransitGatewayPeeringAttachment_Call{Call: _e.mock.On("AcceptTransitGatewayPeeringAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AcceptTransitGatewayPeeringAttachment_Call) Run(run func(ctx context.Context, params *ec2.AcceptTransitGatewayPeeringAttachmentInput, optFns ...func(*ec2.Options))) *EC2_AcceptTransitGatewayPeeringAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AcceptTransitGatewayPeeringAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AcceptTransitGatewayPeeringAttachment_Call) Return(_a0 *ec2.AcceptTransitGatewayPeeringAttachmentOutput, _a1 error) *EC2_AcceptTransitGatewayPeeringAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AcceptTransitGatewayPeeringAttachment_Call) RunAndReturn(run func(context.Context, *ec2.AcceptTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error)) *EC2_AcceptTransitGatewayPeeringAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// AcceptTransitGatewayVpcAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AcceptTransitGatewayVpcAttachment(ctx context.Context, params *ec2.AcceptTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AcceptTransitGatewayVpcAttachment")
	}

	var r0 *ec2.AcceptTransitGatewayVpcAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) *ec2.AcceptTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AcceptTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AcceptTransitGatewayVpcAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptTransitGatewayVpcAttachment'
type EC2_AcceptTransitGatewayVpcAttachment_Call struct {
	*mock.Call
}

// AcceptTransitGatewayVpcAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AcceptTransitGatewayVpcAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AcceptTransitGatewayVpcAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AcceptTransitGatewayVpcAttachment_Call {
	return &EC2_AcceptTransitGatewayVpcAttachment_Call{Call: _e.mock.On("AcceptTransitGatewayVpcAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AcceptTransitGatewayVpcAttachment_Call) Run(run func(ctx context.Context, params *ec2.AcceptTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options))) *EC2_AcceptTransitGatewayVpcAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AcceptTransitGatewayVpcAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AcceptTransitGatewayVpcAttachment_Call) Return(_a0 *ec2.AcceptTransitGatewayVpcAttachmentOutput, _a1 error) *EC2_AcceptTransitGatewayVpcAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AcceptTransitGatewayVpcAttachment_Call) RunAndReturn(run func(context.Context, *ec2.AcceptTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error)) *EC2_AcceptTransitGatewayVpcAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// AcceptVpcEndpointConnections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AcceptVpcEndpointConnections(ctx context.Context, params *ec2.AcceptVpcEndpointConnectionsInput, optFns ...func(*ec2.Options)) (*ec2.AcceptVpcEndpointConnectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AcceptVpcEndpointConnections")
	}

	var r0 *ec2.AcceptVpcEndpointConnectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptVpcEndpointConnectionsInput, ...func(*ec2.Options)) (*ec2.AcceptVpcEndpointConnectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptVpcEndpointConnectionsInput, ...func(*ec2.Options)) *ec2.AcceptVpcEndpointConnectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptVpcEndpointConnectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AcceptVpcEndpointConnectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AcceptVpcEndpointConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptVpcEndpointConnections'
type EC2_AcceptVpcEndpointConnections_Call struct {
	*mock.Call
}

// AcceptVpcEndpointConnections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AcceptVpcEndpointConnectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AcceptVpcEndpointConnections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AcceptVpcEndpointConnections_Call {
	return &EC2_AcceptVpcEndpointConnections_Call{Call: _e.mock.On("AcceptVpcEndpointConnections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AcceptVpcEndpointConnections_Call) Run(run func(ctx context.Context, params *ec2.AcceptVpcEndpointConnectionsInput, optFns ...func(*ec2.Options))) *EC2_AcceptVpcEndpointConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AcceptVpcEndpointConnectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AcceptVpcEndpointConnections_Call) Return(_a0 *ec2.AcceptVpcEndpointConnectionsOutput, _a1 error) *EC2_AcceptVpcEndpointConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AcceptVpcEndpointConnections_Call) RunAndReturn(run func(context.Context, *ec2.AcceptVpcEndpointConnectionsInput, ...func(*ec2.Options)) (*ec2.AcceptVpcEndpointConnectionsOutput, error)) *EC2_AcceptVpcEndpointConnections_Call {
	_c.Call.Return(run)
	return _c
}

// AcceptVpcPeeringConnection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AcceptVpcPeeringConnection(ctx context.Context, params *ec2.AcceptVpcPeeringConnectionInput, optFns ...func(*ec2.Options)) (*ec2.AcceptVpcPeeringConnectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AcceptVpcPeeringConnection")
	}

	var r0 *ec2.AcceptVpcPeeringConnectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptVpcPeeringConnectionInput, ...func(*ec2.Options)) (*ec2.AcceptVpcPeeringConnectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AcceptVpcPeeringConnectionInput, ...func(*ec2.Options)) *ec2.AcceptVpcPeeringConnectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AcceptVpcPeeringConnectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AcceptVpcPeeringConnectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AcceptVpcPeeringConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptVpcPeeringConnection'
type EC2_AcceptVpcPeeringConnection_Call struct {
	*mock.Call
}

// AcceptVpcPeeringConnection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AcceptVpcPeeringConnectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AcceptVpcPeeringConnection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AcceptVpcPeeringConnection_Call {
	return &EC2_AcceptVpcPeeringConnection_Call{Call: _e.mock.On("AcceptVpcPeeringConnection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AcceptVpcPeeringConnection_Call) Run(run func(ctx context.Context, params *ec2.AcceptVpcPeeringConnectionInput, optFns ...func(*ec2.Options))) *EC2_AcceptVpcPeeringConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AcceptVpcPeeringConnectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AcceptVpcPeeringConnection_Call) Return(_a0 *ec2.AcceptVpcPeeringConnectionOutput, _a1 error) *EC2_AcceptVpcPeeringConnection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AcceptVpcPeeringConnection_Call) RunAndReturn(run func(context.Context, *ec2.AcceptVpcPeeringConnectionInput, ...func(*ec2.Options)) (*ec2.AcceptVpcPeeringConnectionOutput, error)) *EC2_AcceptVpcPeeringConnection_Call {
	_c.Call.Return(run)
	return _c
}

// AdvertiseByoipCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AdvertiseByoipCidr(ctx context.Context, params *ec2.AdvertiseByoipCidrInput, optFns ...func(*ec2.Options)) (*ec2.AdvertiseByoipCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AdvertiseByoipCidr")
	}

	var r0 *ec2.AdvertiseByoipCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AdvertiseByoipCidrInput, ...func(*ec2.Options)) (*ec2.AdvertiseByoipCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AdvertiseByoipCidrInput, ...func(*ec2.Options)) *ec2.AdvertiseByoipCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AdvertiseByoipCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AdvertiseByoipCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AdvertiseByoipCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AdvertiseByoipCidr'
type EC2_AdvertiseByoipCidr_Call struct {
	*mock.Call
}

// AdvertiseByoipCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AdvertiseByoipCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AdvertiseByoipCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AdvertiseByoipCidr_Call {
	return &EC2_AdvertiseByoipCidr_Call{Call: _e.mock.On("AdvertiseByoipCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AdvertiseByoipCidr_Call) Run(run func(ctx context.Context, params *ec2.AdvertiseByoipCidrInput, optFns ...func(*ec2.Options))) *EC2_AdvertiseByoipCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AdvertiseByoipCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AdvertiseByoipCidr_Call) Return(_a0 *ec2.AdvertiseByoipCidrOutput, _a1 error) *EC2_AdvertiseByoipCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AdvertiseByoipCidr_Call) RunAndReturn(run func(context.Context, *ec2.AdvertiseByoipCidrInput, ...func(*ec2.Options)) (*ec2.AdvertiseByoipCidrOutput, error)) *EC2_AdvertiseByoipCidr_Call {
	_c.Call.Return(run)
	return _c
}

// AllocateAddress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AllocateAddress(ctx context.Context, params *ec2.AllocateAddressInput, optFns ...func(*ec2.Options)) (*ec2.AllocateAddressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AllocateAddress")
	}

	var r0 *ec2.AllocateAddressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AllocateAddressInput, ...func(*ec2.Options)) (*ec2.AllocateAddressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AllocateAddressInput, ...func(*ec2.Options)) *ec2.AllocateAddressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AllocateAddressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AllocateAddressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AllocateAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllocateAddress'
type EC2_AllocateAddress_Call struct {
	*mock.Call
}

// AllocateAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AllocateAddressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AllocateAddress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AllocateAddress_Call {
	return &EC2_AllocateAddress_Call{Call: _e.mock.On("AllocateAddress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AllocateAddress_Call) Run(run func(ctx context.Context, params *ec2.AllocateAddressInput, optFns ...func(*ec2.Options))) *EC2_AllocateAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AllocateAddressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AllocateAddress_Call) Return(_a0 *ec2.AllocateAddressOutput, _a1 error) *EC2_AllocateAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AllocateAddress_Call) RunAndReturn(run func(context.Context, *ec2.AllocateAddressInput, ...func(*ec2.Options)) (*ec2.AllocateAddressOutput, error)) *EC2_AllocateAddress_Call {
	_c.Call.Return(run)
	return _c
}

// AllocateHosts provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AllocateHosts(ctx context.Context, params *ec2.AllocateHostsInput, optFns ...func(*ec2.Options)) (*ec2.AllocateHostsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AllocateHosts")
	}

	var r0 *ec2.AllocateHostsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AllocateHostsInput, ...func(*ec2.Options)) (*ec2.AllocateHostsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AllocateHostsInput, ...func(*ec2.Options)) *ec2.AllocateHostsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AllocateHostsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AllocateHostsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AllocateHosts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllocateHosts'
type EC2_AllocateHosts_Call struct {
	*mock.Call
}

// AllocateHosts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AllocateHostsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AllocateHosts(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AllocateHosts_Call {
	return &EC2_AllocateHosts_Call{Call: _e.mock.On("AllocateHosts",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AllocateHosts_Call) Run(run func(ctx context.Context, params *ec2.AllocateHostsInput, optFns ...func(*ec2.Options))) *EC2_AllocateHosts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AllocateHostsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AllocateHosts_Call) Return(_a0 *ec2.AllocateHostsOutput, _a1 error) *EC2_AllocateHosts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AllocateHosts_Call) RunAndReturn(run func(context.Context, *ec2.AllocateHostsInput, ...func(*ec2.Options)) (*ec2.AllocateHostsOutput, error)) *EC2_AllocateHosts_Call {
	_c.Call.Return(run)
	return _c
}

// AllocateIpamPoolCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AllocateIpamPoolCidr(ctx context.Context, params *ec2.AllocateIpamPoolCidrInput, optFns ...func(*ec2.Options)) (*ec2.AllocateIpamPoolCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AllocateIpamPoolCidr")
	}

	var r0 *ec2.AllocateIpamPoolCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AllocateIpamPoolCidrInput, ...func(*ec2.Options)) (*ec2.AllocateIpamPoolCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AllocateIpamPoolCidrInput, ...func(*ec2.Options)) *ec2.AllocateIpamPoolCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AllocateIpamPoolCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AllocateIpamPoolCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AllocateIpamPoolCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllocateIpamPoolCidr'
type EC2_AllocateIpamPoolCidr_Call struct {
	*mock.Call
}

// AllocateIpamPoolCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AllocateIpamPoolCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AllocateIpamPoolCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AllocateIpamPoolCidr_Call {
	return &EC2_AllocateIpamPoolCidr_Call{Call: _e.mock.On("AllocateIpamPoolCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AllocateIpamPoolCidr_Call) Run(run func(ctx context.Context, params *ec2.AllocateIpamPoolCidrInput, optFns ...func(*ec2.Options))) *EC2_AllocateIpamPoolCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AllocateIpamPoolCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AllocateIpamPoolCidr_Call) Return(_a0 *ec2.AllocateIpamPoolCidrOutput, _a1 error) *EC2_AllocateIpamPoolCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AllocateIpamPoolCidr_Call) RunAndReturn(run func(context.Context, *ec2.AllocateIpamPoolCidrInput, ...func(*ec2.Options)) (*ec2.AllocateIpamPoolCidrOutput, error)) *EC2_AllocateIpamPoolCidr_Call {
	_c.Call.Return(run)
	return _c
}

// ApplySecurityGroupsToClientVpnTargetNetwork provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ApplySecurityGroupsToClientVpnTargetNetwork(ctx context.Context, params *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, optFns ...func(*ec2.Options)) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ApplySecurityGroupsToClientVpnTargetNetwork")
	}

	var r0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, ...func(*ec2.Options)) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, ...func(*ec2.Options)) *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplySecurityGroupsToClientVpnTargetNetwork'
type EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call struct {
	*mock.Call
}

// ApplySecurityGroupsToClientVpnTargetNetwork is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ApplySecurityGroupsToClientVpnTargetNetwork(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call {
	return &EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call{Call: _e.mock.On("ApplySecurityGroupsToClientVpnTargetNetwork",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call) Run(run func(ctx context.Context, params *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, optFns ...func(*ec2.Options))) *EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call) Return(_a0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, _a1 error) *EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call) RunAndReturn(run func(context.Context, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, ...func(*ec2.Options)) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error)) *EC2_ApplySecurityGroupsToClientVpnTargetNetwork_Call {
	_c.Call.Return(run)
	return _c
}

// AssignIpv6Addresses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssignIpv6Addresses(ctx context.Context, params *ec2.AssignIpv6AddressesInput, optFns ...func(*ec2.Options)) (*ec2.AssignIpv6AddressesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssignIpv6Addresses")
	}

	var r0 *ec2.AssignIpv6AddressesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssignIpv6AddressesInput, ...func(*ec2.Options)) (*ec2.AssignIpv6AddressesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssignIpv6AddressesInput, ...func(*ec2.Options)) *ec2.AssignIpv6AddressesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssignIpv6AddressesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssignIpv6AddressesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssignIpv6Addresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignIpv6Addresses'
type EC2_AssignIpv6Addresses_Call struct {
	*mock.Call
}

// AssignIpv6Addresses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssignIpv6AddressesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssignIpv6Addresses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssignIpv6Addresses_Call {
	return &EC2_AssignIpv6Addresses_Call{Call: _e.mock.On("AssignIpv6Addresses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssignIpv6Addresses_Call) Run(run func(ctx context.Context, params *ec2.AssignIpv6AddressesInput, optFns ...func(*ec2.Options))) *EC2_AssignIpv6Addresses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssignIpv6AddressesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssignIpv6Addresses_Call) Return(_a0 *ec2.AssignIpv6AddressesOutput, _a1 error) *EC2_AssignIpv6Addresses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssignIpv6Addresses_Call) RunAndReturn(run func(context.Context, *ec2.AssignIpv6AddressesInput, ...func(*ec2.Options)) (*ec2.AssignIpv6AddressesOutput, error)) *EC2_AssignIpv6Addresses_Call {
	_c.Call.Return(run)
	return _c
}

// AssignPrivateIpAddresses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssignPrivateIpAddresses(ctx context.Context, params *ec2.AssignPrivateIpAddressesInput, optFns ...func(*ec2.Options)) (*ec2.AssignPrivateIpAddressesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssignPrivateIpAddresses")
	}

	var r0 *ec2.AssignPrivateIpAddressesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssignPrivateIpAddressesInput, ...func(*ec2.Options)) (*ec2.AssignPrivateIpAddressesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssignPrivateIpAddressesInput, ...func(*ec2.Options)) *ec2.AssignPrivateIpAddressesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssignPrivateIpAddressesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssignPrivateIpAddressesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssignPrivateIpAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignPrivateIpAddresses'
type EC2_AssignPrivateIpAddresses_Call struct {
	*mock.Call
}

// AssignPrivateIpAddresses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssignPrivateIpAddressesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssignPrivateIpAddresses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssignPrivateIpAddresses_Call {
	return &EC2_AssignPrivateIpAddresses_Call{Call: _e.mock.On("AssignPrivateIpAddresses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssignPrivateIpAddresses_Call) Run(run func(ctx context.Context, params *ec2.AssignPrivateIpAddressesInput, optFns ...func(*ec2.Options))) *EC2_AssignPrivateIpAddresses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssignPrivateIpAddressesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssignPrivateIpAddresses_Call) Return(_a0 *ec2.AssignPrivateIpAddressesOutput, _a1 error) *EC2_AssignPrivateIpAddresses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssignPrivateIpAddresses_Call) RunAndReturn(run func(context.Context, *ec2.AssignPrivateIpAddressesInput, ...func(*ec2.Options)) (*ec2.AssignPrivateIpAddressesOutput, error)) *EC2_AssignPrivateIpAddresses_Call {
	_c.Call.Return(run)
	return _c
}

// AssignPrivateNatGatewayAddress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssignPrivateNatGatewayAddress(ctx context.Context, params *ec2.AssignPrivateNatGatewayAddressInput, optFns ...func(*ec2.Options)) (*ec2.AssignPrivateNatGatewayAddressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssignPrivateNatGatewayAddress")
	}

	var r0 *ec2.AssignPrivateNatGatewayAddressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssignPrivateNatGatewayAddressInput, ...func(*ec2.Options)) (*ec2.AssignPrivateNatGatewayAddressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssignPrivateNatGatewayAddressInput, ...func(*ec2.Options)) *ec2.AssignPrivateNatGatewayAddressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssignPrivateNatGatewayAddressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssignPrivateNatGatewayAddressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssignPrivateNatGatewayAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignPrivateNatGatewayAddress'
type EC2_AssignPrivateNatGatewayAddress_Call struct {
	*mock.Call
}

// AssignPrivateNatGatewayAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssignPrivateNatGatewayAddressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssignPrivateNatGatewayAddress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssignPrivateNatGatewayAddress_Call {
	return &EC2_AssignPrivateNatGatewayAddress_Call{Call: _e.mock.On("AssignPrivateNatGatewayAddress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssignPrivateNatGatewayAddress_Call) Run(run func(ctx context.Context, params *ec2.AssignPrivateNatGatewayAddressInput, optFns ...func(*ec2.Options))) *EC2_AssignPrivateNatGatewayAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssignPrivateNatGatewayAddressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssignPrivateNatGatewayAddress_Call) Return(_a0 *ec2.AssignPrivateNatGatewayAddressOutput, _a1 error) *EC2_AssignPrivateNatGatewayAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssignPrivateNatGatewayAddress_Call) RunAndReturn(run func(context.Context, *ec2.AssignPrivateNatGatewayAddressInput, ...func(*ec2.Options)) (*ec2.AssignPrivateNatGatewayAddressOutput, error)) *EC2_AssignPrivateNatGatewayAddress_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateAddress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateAddress(ctx context.Context, params *ec2.AssociateAddressInput, optFns ...func(*ec2.Options)) (*ec2.AssociateAddressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateAddress")
	}

	var r0 *ec2.AssociateAddressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateAddressInput, ...func(*ec2.Options)) (*ec2.AssociateAddressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateAddressInput, ...func(*ec2.Options)) *ec2.AssociateAddressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateAddressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateAddressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateAddress'
type EC2_AssociateAddress_Call struct {
	*mock.Call
}

// AssociateAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateAddressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateAddress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateAddress_Call {
	return &EC2_AssociateAddress_Call{Call: _e.mock.On("AssociateAddress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateAddress_Call) Run(run func(ctx context.Context, params *ec2.AssociateAddressInput, optFns ...func(*ec2.Options))) *EC2_AssociateAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateAddressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateAddress_Call) Return(_a0 *ec2.AssociateAddressOutput, _a1 error) *EC2_AssociateAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateAddress_Call) RunAndReturn(run func(context.Context, *ec2.AssociateAddressInput, ...func(*ec2.Options)) (*ec2.AssociateAddressOutput, error)) *EC2_AssociateAddress_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateCapacityReservationBillingOwner provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateCapacityReservationBillingOwner(ctx context.Context, params *ec2.AssociateCapacityReservationBillingOwnerInput, optFns ...func(*ec2.Options)) (*ec2.AssociateCapacityReservationBillingOwnerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateCapacityReservationBillingOwner")
	}

	var r0 *ec2.AssociateCapacityReservationBillingOwnerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateCapacityReservationBillingOwnerInput, ...func(*ec2.Options)) (*ec2.AssociateCapacityReservationBillingOwnerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateCapacityReservationBillingOwnerInput, ...func(*ec2.Options)) *ec2.AssociateCapacityReservationBillingOwnerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateCapacityReservationBillingOwnerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateCapacityReservationBillingOwnerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateCapacityReservationBillingOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateCapacityReservationBillingOwner'
type EC2_AssociateCapacityReservationBillingOwner_Call struct {
	*mock.Call
}

// AssociateCapacityReservationBillingOwner is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateCapacityReservationBillingOwnerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateCapacityReservationBillingOwner(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateCapacityReservationBillingOwner_Call {
	return &EC2_AssociateCapacityReservationBillingOwner_Call{Call: _e.mock.On("AssociateCapacityReservationBillingOwner",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateCapacityReservationBillingOwner_Call) Run(run func(ctx context.Context, params *ec2.AssociateCapacityReservationBillingOwnerInput, optFns ...func(*ec2.Options))) *EC2_AssociateCapacityReservationBillingOwner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateCapacityReservationBillingOwnerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateCapacityReservationBillingOwner_Call) Return(_a0 *ec2.AssociateCapacityReservationBillingOwnerOutput, _a1 error) *EC2_AssociateCapacityReservationBillingOwner_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateCapacityReservationBillingOwner_Call) RunAndReturn(run func(context.Context, *ec2.AssociateCapacityReservationBillingOwnerInput, ...func(*ec2.Options)) (*ec2.AssociateCapacityReservationBillingOwnerOutput, error)) *EC2_AssociateCapacityReservationBillingOwner_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateClientVpnTargetNetwork provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateClientVpnTargetNetwork(ctx context.Context, params *ec2.AssociateClientVpnTargetNetworkInput, optFns ...func(*ec2.Options)) (*ec2.AssociateClientVpnTargetNetworkOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateClientVpnTargetNetwork")
	}

	var r0 *ec2.AssociateClientVpnTargetNetworkOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateClientVpnTargetNetworkInput, ...func(*ec2.Options)) (*ec2.AssociateClientVpnTargetNetworkOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateClientVpnTargetNetworkInput, ...func(*ec2.Options)) *ec2.AssociateClientVpnTargetNetworkOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateClientVpnTargetNetworkOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateClientVpnTargetNetworkInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateClientVpnTargetNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateClientVpnTargetNetwork'
type EC2_AssociateClientVpnTargetNetwork_Call struct {
	*mock.Call
}

// AssociateClientVpnTargetNetwork is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateClientVpnTargetNetworkInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateClientVpnTargetNetwork(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateClientVpnTargetNetwork_Call {
	return &EC2_AssociateClientVpnTargetNetwork_Call{Call: _e.mock.On("AssociateClientVpnTargetNetwork",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateClientVpnTargetNetwork_Call) Run(run func(ctx context.Context, params *ec2.AssociateClientVpnTargetNetworkInput, optFns ...func(*ec2.Options))) *EC2_AssociateClientVpnTargetNetwork_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateClientVpnTargetNetworkInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateClientVpnTargetNetwork_Call) Return(_a0 *ec2.AssociateClientVpnTargetNetworkOutput, _a1 error) *EC2_AssociateClientVpnTargetNetwork_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateClientVpnTargetNetwork_Call) RunAndReturn(run func(context.Context, *ec2.AssociateClientVpnTargetNetworkInput, ...func(*ec2.Options)) (*ec2.AssociateClientVpnTargetNetworkOutput, error)) *EC2_AssociateClientVpnTargetNetwork_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateDhcpOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateDhcpOptions(ctx context.Context, params *ec2.AssociateDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.AssociateDhcpOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateDhcpOptions")
	}

	var r0 *ec2.AssociateDhcpOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateDhcpOptionsInput, ...func(*ec2.Options)) (*ec2.AssociateDhcpOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateDhcpOptionsInput, ...func(*ec2.Options)) *ec2.AssociateDhcpOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateDhcpOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateDhcpOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateDhcpOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateDhcpOptions'
type EC2_AssociateDhcpOptions_Call struct {
	*mock.Call
}

// AssociateDhcpOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateDhcpOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateDhcpOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateDhcpOptions_Call {
	return &EC2_AssociateDhcpOptions_Call{Call: _e.mock.On("AssociateDhcpOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateDhcpOptions_Call) Run(run func(ctx context.Context, params *ec2.AssociateDhcpOptionsInput, optFns ...func(*ec2.Options))) *EC2_AssociateDhcpOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateDhcpOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateDhcpOptions_Call) Return(_a0 *ec2.AssociateDhcpOptionsOutput, _a1 error) *EC2_AssociateDhcpOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateDhcpOptions_Call) RunAndReturn(run func(context.Context, *ec2.AssociateDhcpOptionsInput, ...func(*ec2.Options)) (*ec2.AssociateDhcpOptionsOutput, error)) *EC2_AssociateDhcpOptions_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateEnclaveCertificateIamRole provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateEnclaveCertificateIamRole(ctx context.Context, params *ec2.AssociateEnclaveCertificateIamRoleInput, optFns ...func(*ec2.Options)) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateEnclaveCertificateIamRole")
	}

	var r0 *ec2.AssociateEnclaveCertificateIamRoleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateEnclaveCertificateIamRoleInput, ...func(*ec2.Options)) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateEnclaveCertificateIamRoleInput, ...func(*ec2.Options)) *ec2.AssociateEnclaveCertificateIamRoleOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateEnclaveCertificateIamRoleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateEnclaveCertificateIamRoleInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateEnclaveCertificateIamRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateEnclaveCertificateIamRole'
type EC2_AssociateEnclaveCertificateIamRole_Call struct {
	*mock.Call
}

// AssociateEnclaveCertificateIamRole is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateEnclaveCertificateIamRoleInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateEnclaveCertificateIamRole(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateEnclaveCertificateIamRole_Call {
	return &EC2_AssociateEnclaveCertificateIamRole_Call{Call: _e.mock.On("AssociateEnclaveCertificateIamRole",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateEnclaveCertificateIamRole_Call) Run(run func(ctx context.Context, params *ec2.AssociateEnclaveCertificateIamRoleInput, optFns ...func(*ec2.Options))) *EC2_AssociateEnclaveCertificateIamRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateEnclaveCertificateIamRoleInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateEnclaveCertificateIamRole_Call) Return(_a0 *ec2.AssociateEnclaveCertificateIamRoleOutput, _a1 error) *EC2_AssociateEnclaveCertificateIamRole_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateEnclaveCertificateIamRole_Call) RunAndReturn(run func(context.Context, *ec2.AssociateEnclaveCertificateIamRoleInput, ...func(*ec2.Options)) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error)) *EC2_AssociateEnclaveCertificateIamRole_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateIamInstanceProfile provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateIamInstanceProfile(ctx context.Context, params *ec2.AssociateIamInstanceProfileInput, optFns ...func(*ec2.Options)) (*ec2.AssociateIamInstanceProfileOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateIamInstanceProfile")
	}

	var r0 *ec2.AssociateIamInstanceProfileOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateIamInstanceProfileInput, ...func(*ec2.Options)) (*ec2.AssociateIamInstanceProfileOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateIamInstanceProfileInput, ...func(*ec2.Options)) *ec2.AssociateIamInstanceProfileOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateIamInstanceProfileOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateIamInstanceProfileInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateIamInstanceProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateIamInstanceProfile'
type EC2_AssociateIamInstanceProfile_Call struct {
	*mock.Call
}

// AssociateIamInstanceProfile is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateIamInstanceProfileInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateIamInstanceProfile(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateIamInstanceProfile_Call {
	return &EC2_AssociateIamInstanceProfile_Call{Call: _e.mock.On("AssociateIamInstanceProfile",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateIamInstanceProfile_Call) Run(run func(ctx context.Context, params *ec2.AssociateIamInstanceProfileInput, optFns ...func(*ec2.Options))) *EC2_AssociateIamInstanceProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateIamInstanceProfileInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateIamInstanceProfile_Call) Return(_a0 *ec2.AssociateIamInstanceProfileOutput, _a1 error) *EC2_AssociateIamInstanceProfile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateIamInstanceProfile_Call) RunAndReturn(run func(context.Context, *ec2.AssociateIamInstanceProfileInput, ...func(*ec2.Options)) (*ec2.AssociateIamInstanceProfileOutput, error)) *EC2_AssociateIamInstanceProfile_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateInstanceEventWindow provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateInstanceEventWindow(ctx context.Context, params *ec2.AssociateInstanceEventWindowInput, optFns ...func(*ec2.Options)) (*ec2.AssociateInstanceEventWindowOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateInstanceEventWindow")
	}

	var r0 *ec2.AssociateInstanceEventWindowOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.AssociateInstanceEventWindowOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateInstanceEventWindowInput, ...func(*ec2.Options)) *ec2.AssociateInstanceEventWindowOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateInstanceEventWindowOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateInstanceEventWindowInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateInstanceEventWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateInstanceEventWindow'
type EC2_AssociateInstanceEventWindow_Call struct {
	*mock.Call
}

// AssociateInstanceEventWindow is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateInstanceEventWindowInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateInstanceEventWindow(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateInstanceEventWindow_Call {
	return &EC2_AssociateInstanceEventWindow_Call{Call: _e.mock.On("AssociateInstanceEventWindow",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateInstanceEventWindow_Call) Run(run func(ctx context.Context, params *ec2.AssociateInstanceEventWindowInput, optFns ...func(*ec2.Options))) *EC2_AssociateInstanceEventWindow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateInstanceEventWindowInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateInstanceEventWindow_Call) Return(_a0 *ec2.AssociateInstanceEventWindowOutput, _a1 error) *EC2_AssociateInstanceEventWindow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateInstanceEventWindow_Call) RunAndReturn(run func(context.Context, *ec2.AssociateInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.AssociateInstanceEventWindowOutput, error)) *EC2_AssociateInstanceEventWindow_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateIpamByoasn provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateIpamByoasn(ctx context.Context, params *ec2.AssociateIpamByoasnInput, optFns ...func(*ec2.Options)) (*ec2.AssociateIpamByoasnOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateIpamByoasn")
	}

	var r0 *ec2.AssociateIpamByoasnOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateIpamByoasnInput, ...func(*ec2.Options)) (*ec2.AssociateIpamByoasnOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateIpamByoasnInput, ...func(*ec2.Options)) *ec2.AssociateIpamByoasnOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateIpamByoasnOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateIpamByoasnInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateIpamByoasn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateIpamByoasn'
type EC2_AssociateIpamByoasn_Call struct {
	*mock.Call
}

// AssociateIpamByoasn is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateIpamByoasnInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateIpamByoasn(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateIpamByoasn_Call {
	return &EC2_AssociateIpamByoasn_Call{Call: _e.mock.On("AssociateIpamByoasn",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateIpamByoasn_Call) Run(run func(ctx context.Context, params *ec2.AssociateIpamByoasnInput, optFns ...func(*ec2.Options))) *EC2_AssociateIpamByoasn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateIpamByoasnInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateIpamByoasn_Call) Return(_a0 *ec2.AssociateIpamByoasnOutput, _a1 error) *EC2_AssociateIpamByoasn_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateIpamByoasn_Call) RunAndReturn(run func(context.Context, *ec2.AssociateIpamByoasnInput, ...func(*ec2.Options)) (*ec2.AssociateIpamByoasnOutput, error)) *EC2_AssociateIpamByoasn_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateIpamResourceDiscovery provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateIpamResourceDiscovery(ctx context.Context, params *ec2.AssociateIpamResourceDiscoveryInput, optFns ...func(*ec2.Options)) (*ec2.AssociateIpamResourceDiscoveryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateIpamResourceDiscovery")
	}

	var r0 *ec2.AssociateIpamResourceDiscoveryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.AssociateIpamResourceDiscoveryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateIpamResourceDiscoveryInput, ...func(*ec2.Options)) *ec2.AssociateIpamResourceDiscoveryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateIpamResourceDiscoveryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateIpamResourceDiscoveryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateIpamResourceDiscovery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateIpamResourceDiscovery'
type EC2_AssociateIpamResourceDiscovery_Call struct {
	*mock.Call
}

// AssociateIpamResourceDiscovery is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateIpamResourceDiscoveryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateIpamResourceDiscovery(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateIpamResourceDiscovery_Call {
	return &EC2_AssociateIpamResourceDiscovery_Call{Call: _e.mock.On("AssociateIpamResourceDiscovery",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateIpamResourceDiscovery_Call) Run(run func(ctx context.Context, params *ec2.AssociateIpamResourceDiscoveryInput, optFns ...func(*ec2.Options))) *EC2_AssociateIpamResourceDiscovery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateIpamResourceDiscoveryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateIpamResourceDiscovery_Call) Return(_a0 *ec2.AssociateIpamResourceDiscoveryOutput, _a1 error) *EC2_AssociateIpamResourceDiscovery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateIpamResourceDiscovery_Call) RunAndReturn(run func(context.Context, *ec2.AssociateIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.AssociateIpamResourceDiscoveryOutput, error)) *EC2_AssociateIpamResourceDiscovery_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateNatGatewayAddress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateNatGatewayAddress(ctx context.Context, params *ec2.AssociateNatGatewayAddressInput, optFns ...func(*ec2.Options)) (*ec2.AssociateNatGatewayAddressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateNatGatewayAddress")
	}

	var r0 *ec2.AssociateNatGatewayAddressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateNatGatewayAddressInput, ...func(*ec2.Options)) (*ec2.AssociateNatGatewayAddressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateNatGatewayAddressInput, ...func(*ec2.Options)) *ec2.AssociateNatGatewayAddressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateNatGatewayAddressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateNatGatewayAddressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateNatGatewayAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateNatGatewayAddress'
type EC2_AssociateNatGatewayAddress_Call struct {
	*mock.Call
}

// AssociateNatGatewayAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateNatGatewayAddressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateNatGatewayAddress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateNatGatewayAddress_Call {
	return &EC2_AssociateNatGatewayAddress_Call{Call: _e.mock.On("AssociateNatGatewayAddress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateNatGatewayAddress_Call) Run(run func(ctx context.Context, params *ec2.AssociateNatGatewayAddressInput, optFns ...func(*ec2.Options))) *EC2_AssociateNatGatewayAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateNatGatewayAddressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateNatGatewayAddress_Call) Return(_a0 *ec2.AssociateNatGatewayAddressOutput, _a1 error) *EC2_AssociateNatGatewayAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateNatGatewayAddress_Call) RunAndReturn(run func(context.Context, *ec2.AssociateNatGatewayAddressInput, ...func(*ec2.Options)) (*ec2.AssociateNatGatewayAddressOutput, error)) *EC2_AssociateNatGatewayAddress_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateRouteServer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateRouteServer(ctx context.Context, params *ec2.AssociateRouteServerInput, optFns ...func(*ec2.Options)) (*ec2.AssociateRouteServerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateRouteServer")
	}

	var r0 *ec2.AssociateRouteServerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateRouteServerInput, ...func(*ec2.Options)) (*ec2.AssociateRouteServerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateRouteServerInput, ...func(*ec2.Options)) *ec2.AssociateRouteServerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateRouteServerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateRouteServerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateRouteServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateRouteServer'
type EC2_AssociateRouteServer_Call struct {
	*mock.Call
}

// AssociateRouteServer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateRouteServerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateRouteServer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateRouteServer_Call {
	return &EC2_AssociateRouteServer_Call{Call: _e.mock.On("AssociateRouteServer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateRouteServer_Call) Run(run func(ctx context.Context, params *ec2.AssociateRouteServerInput, optFns ...func(*ec2.Options))) *EC2_AssociateRouteServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateRouteServerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateRouteServer_Call) Return(_a0 *ec2.AssociateRouteServerOutput, _a1 error) *EC2_AssociateRouteServer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateRouteServer_Call) RunAndReturn(run func(context.Context, *ec2.AssociateRouteServerInput, ...func(*ec2.Options)) (*ec2.AssociateRouteServerOutput, error)) *EC2_AssociateRouteServer_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateRouteTable(ctx context.Context, params *ec2.AssociateRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.AssociateRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateRouteTable")
	}

	var r0 *ec2.AssociateRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateRouteTableInput, ...func(*ec2.Options)) (*ec2.AssociateRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateRouteTableInput, ...func(*ec2.Options)) *ec2.AssociateRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateRouteTable'
type EC2_AssociateRouteTable_Call struct {
	*mock.Call
}

// AssociateRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateRouteTable_Call {
	return &EC2_AssociateRouteTable_Call{Call: _e.mock.On("AssociateRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateRouteTable_Call) Run(run func(ctx context.Context, params *ec2.AssociateRouteTableInput, optFns ...func(*ec2.Options))) *EC2_AssociateRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateRouteTable_Call) Return(_a0 *ec2.AssociateRouteTableOutput, _a1 error) *EC2_AssociateRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.AssociateRouteTableInput, ...func(*ec2.Options)) (*ec2.AssociateRouteTableOutput, error)) *EC2_AssociateRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateSecurityGroupVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateSecurityGroupVpc(ctx context.Context, params *ec2.AssociateSecurityGroupVpcInput, optFns ...func(*ec2.Options)) (*ec2.AssociateSecurityGroupVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateSecurityGroupVpc")
	}

	var r0 *ec2.AssociateSecurityGroupVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateSecurityGroupVpcInput, ...func(*ec2.Options)) (*ec2.AssociateSecurityGroupVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateSecurityGroupVpcInput, ...func(*ec2.Options)) *ec2.AssociateSecurityGroupVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateSecurityGroupVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateSecurityGroupVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateSecurityGroupVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateSecurityGroupVpc'
type EC2_AssociateSecurityGroupVpc_Call struct {
	*mock.Call
}

// AssociateSecurityGroupVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateSecurityGroupVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateSecurityGroupVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateSecurityGroupVpc_Call {
	return &EC2_AssociateSecurityGroupVpc_Call{Call: _e.mock.On("AssociateSecurityGroupVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateSecurityGroupVpc_Call) Run(run func(ctx context.Context, params *ec2.AssociateSecurityGroupVpcInput, optFns ...func(*ec2.Options))) *EC2_AssociateSecurityGroupVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateSecurityGroupVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateSecurityGroupVpc_Call) Return(_a0 *ec2.AssociateSecurityGroupVpcOutput, _a1 error) *EC2_AssociateSecurityGroupVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateSecurityGroupVpc_Call) RunAndReturn(run func(context.Context, *ec2.AssociateSecurityGroupVpcInput, ...func(*ec2.Options)) (*ec2.AssociateSecurityGroupVpcOutput, error)) *EC2_AssociateSecurityGroupVpc_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateSubnetCidrBlock provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateSubnetCidrBlock(ctx context.Context, params *ec2.AssociateSubnetCidrBlockInput, optFns ...func(*ec2.Options)) (*ec2.AssociateSubnetCidrBlockOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateSubnetCidrBlock")
	}

	var r0 *ec2.AssociateSubnetCidrBlockOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateSubnetCidrBlockInput, ...func(*ec2.Options)) (*ec2.AssociateSubnetCidrBlockOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateSubnetCidrBlockInput, ...func(*ec2.Options)) *ec2.AssociateSubnetCidrBlockOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateSubnetCidrBlockOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateSubnetCidrBlockInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateSubnetCidrBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateSubnetCidrBlock'
type EC2_AssociateSubnetCidrBlock_Call struct {
	*mock.Call
}

// AssociateSubnetCidrBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateSubnetCidrBlockInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateSubnetCidrBlock(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateSubnetCidrBlock_Call {
	return &EC2_AssociateSubnetCidrBlock_Call{Call: _e.mock.On("AssociateSubnetCidrBlock",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateSubnetCidrBlock_Call) Run(run func(ctx context.Context, params *ec2.AssociateSubnetCidrBlockInput, optFns ...func(*ec2.Options))) *EC2_AssociateSubnetCidrBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateSubnetCidrBlockInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateSubnetCidrBlock_Call) Return(_a0 *ec2.AssociateSubnetCidrBlockOutput, _a1 error) *EC2_AssociateSubnetCidrBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateSubnetCidrBlock_Call) RunAndReturn(run func(context.Context, *ec2.AssociateSubnetCidrBlockInput, ...func(*ec2.Options)) (*ec2.AssociateSubnetCidrBlockOutput, error)) *EC2_AssociateSubnetCidrBlock_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateTransitGatewayMulticastDomain provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateTransitGatewayMulticastDomain(ctx context.Context, params *ec2.AssociateTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateTransitGatewayMulticastDomain")
	}

	var r0 *ec2.AssociateTransitGatewayMulticastDomainOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) *ec2.AssociateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTransitGatewayMulticastDomainOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateTransitGatewayMulticastDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateTransitGatewayMulticastDomain'
type EC2_AssociateTransitGatewayMulticastDomain_Call struct {
	*mock.Call
}

// AssociateTransitGatewayMulticastDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateTransitGatewayMulticastDomainInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateTransitGatewayMulticastDomain(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateTransitGatewayMulticastDomain_Call {
	return &EC2_AssociateTransitGatewayMulticastDomain_Call{Call: _e.mock.On("AssociateTransitGatewayMulticastDomain",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateTransitGatewayMulticastDomain_Call) Run(run func(ctx context.Context, params *ec2.AssociateTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options))) *EC2_AssociateTransitGatewayMulticastDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateTransitGatewayMulticastDomainInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateTransitGatewayMulticastDomain_Call) Return(_a0 *ec2.AssociateTransitGatewayMulticastDomainOutput, _a1 error) *EC2_AssociateTransitGatewayMulticastDomain_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateTransitGatewayMulticastDomain_Call) RunAndReturn(run func(context.Context, *ec2.AssociateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error)) *EC2_AssociateTransitGatewayMulticastDomain_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateTransitGatewayPolicyTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateTransitGatewayPolicyTable(ctx context.Context, params *ec2.AssociateTransitGatewayPolicyTableInput, optFns ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayPolicyTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateTransitGatewayPolicyTable")
	}

	var r0 *ec2.AssociateTransitGatewayPolicyTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayPolicyTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) *ec2.AssociateTransitGatewayPolicyTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTransitGatewayPolicyTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateTransitGatewayPolicyTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateTransitGatewayPolicyTable'
type EC2_AssociateTransitGatewayPolicyTable_Call struct {
	*mock.Call
}

// AssociateTransitGatewayPolicyTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateTransitGatewayPolicyTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateTransitGatewayPolicyTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateTransitGatewayPolicyTable_Call {
	return &EC2_AssociateTransitGatewayPolicyTable_Call{Call: _e.mock.On("AssociateTransitGatewayPolicyTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateTransitGatewayPolicyTable_Call) Run(run func(ctx context.Context, params *ec2.AssociateTransitGatewayPolicyTableInput, optFns ...func(*ec2.Options))) *EC2_AssociateTransitGatewayPolicyTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateTransitGatewayPolicyTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateTransitGatewayPolicyTable_Call) Return(_a0 *ec2.AssociateTransitGatewayPolicyTableOutput, _a1 error) *EC2_AssociateTransitGatewayPolicyTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateTransitGatewayPolicyTable_Call) RunAndReturn(run func(context.Context, *ec2.AssociateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayPolicyTableOutput, error)) *EC2_AssociateTransitGatewayPolicyTable_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateTransitGatewayRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateTransitGatewayRouteTable(ctx context.Context, params *ec2.AssociateTransitGatewayRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateTransitGatewayRouteTable")
	}

	var r0 *ec2.AssociateTransitGatewayRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTransitGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTransitGatewayRouteTableInput, ...func(*ec2.Options)) *ec2.AssociateTransitGatewayRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTransitGatewayRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateTransitGatewayRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateTransitGatewayRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateTransitGatewayRouteTable'
type EC2_AssociateTransitGatewayRouteTable_Call struct {
	*mock.Call
}

// AssociateTransitGatewayRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateTransitGatewayRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateTransitGatewayRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateTransitGatewayRouteTable_Call {
	return &EC2_AssociateTransitGatewayRouteTable_Call{Call: _e.mock.On("AssociateTransitGatewayRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateTransitGatewayRouteTable_Call) Run(run func(ctx context.Context, params *ec2.AssociateTransitGatewayRouteTableInput, optFns ...func(*ec2.Options))) *EC2_AssociateTransitGatewayRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateTransitGatewayRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateTransitGatewayRouteTable_Call) Return(_a0 *ec2.AssociateTransitGatewayRouteTableOutput, _a1 error) *EC2_AssociateTransitGatewayRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateTransitGatewayRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.AssociateTransitGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.AssociateTransitGatewayRouteTableOutput, error)) *EC2_AssociateTransitGatewayRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateTrunkInterface provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateTrunkInterface(ctx context.Context, params *ec2.AssociateTrunkInterfaceInput, optFns ...func(*ec2.Options)) (*ec2.AssociateTrunkInterfaceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateTrunkInterface")
	}

	var r0 *ec2.AssociateTrunkInterfaceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTrunkInterfaceInput, ...func(*ec2.Options)) (*ec2.AssociateTrunkInterfaceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateTrunkInterfaceInput, ...func(*ec2.Options)) *ec2.AssociateTrunkInterfaceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateTrunkInterfaceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateTrunkInterfaceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateTrunkInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateTrunkInterface'
type EC2_AssociateTrunkInterface_Call struct {
	*mock.Call
}

// AssociateTrunkInterface is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateTrunkInterfaceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateTrunkInterface(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateTrunkInterface_Call {
	return &EC2_AssociateTrunkInterface_Call{Call: _e.mock.On("AssociateTrunkInterface",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateTrunkInterface_Call) Run(run func(ctx context.Context, params *ec2.AssociateTrunkInterfaceInput, optFns ...func(*ec2.Options))) *EC2_AssociateTrunkInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateTrunkInterfaceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateTrunkInterface_Call) Return(_a0 *ec2.AssociateTrunkInterfaceOutput, _a1 error) *EC2_AssociateTrunkInterface_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateTrunkInterface_Call) RunAndReturn(run func(context.Context, *ec2.AssociateTrunkInterfaceInput, ...func(*ec2.Options)) (*ec2.AssociateTrunkInterfaceOutput, error)) *EC2_AssociateTrunkInterface_Call {
	_c.Call.Return(run)
	return _c
}

// AssociateVpcCidrBlock provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AssociateVpcCidrBlock(ctx context.Context, params *ec2.AssociateVpcCidrBlockInput, optFns ...func(*ec2.Options)) (*ec2.AssociateVpcCidrBlockOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AssociateVpcCidrBlock")
	}

	var r0 *ec2.AssociateVpcCidrBlockOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateVpcCidrBlockInput, ...func(*ec2.Options)) (*ec2.AssociateVpcCidrBlockOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AssociateVpcCidrBlockInput, ...func(*ec2.Options)) *ec2.AssociateVpcCidrBlockOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AssociateVpcCidrBlockOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AssociateVpcCidrBlockInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AssociateVpcCidrBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssociateVpcCidrBlock'
type EC2_AssociateVpcCidrBlock_Call struct {
	*mock.Call
}

// AssociateVpcCidrBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AssociateVpcCidrBlockInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AssociateVpcCidrBlock(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AssociateVpcCidrBlock_Call {
	return &EC2_AssociateVpcCidrBlock_Call{Call: _e.mock.On("AssociateVpcCidrBlock",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AssociateVpcCidrBlock_Call) Run(run func(ctx context.Context, params *ec2.AssociateVpcCidrBlockInput, optFns ...func(*ec2.Options))) *EC2_AssociateVpcCidrBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AssociateVpcCidrBlockInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AssociateVpcCidrBlock_Call) Return(_a0 *ec2.AssociateVpcCidrBlockOutput, _a1 error) *EC2_AssociateVpcCidrBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AssociateVpcCidrBlock_Call) RunAndReturn(run func(context.Context, *ec2.AssociateVpcCidrBlockInput, ...func(*ec2.Options)) (*ec2.AssociateVpcCidrBlockOutput, error)) *EC2_AssociateVpcCidrBlock_Call {
	_c.Call.Return(run)
	return _c
}

// AttachClassicLinkVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AttachClassicLinkVpc(ctx context.Context, params *ec2.AttachClassicLinkVpcInput, optFns ...func(*ec2.Options)) (*ec2.AttachClassicLinkVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AttachClassicLinkVpc")
	}

	var r0 *ec2.AttachClassicLinkVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachClassicLinkVpcInput, ...func(*ec2.Options)) (*ec2.AttachClassicLinkVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachClassicLinkVpcInput, ...func(*ec2.Options)) *ec2.AttachClassicLinkVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachClassicLinkVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AttachClassicLinkVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AttachClassicLinkVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachClassicLinkVpc'
type EC2_AttachClassicLinkVpc_Call struct {
	*mock.Call
}

// AttachClassicLinkVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AttachClassicLinkVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AttachClassicLinkVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AttachClassicLinkVpc_Call {
	return &EC2_AttachClassicLinkVpc_Call{Call: _e.mock.On("AttachClassicLinkVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AttachClassicLinkVpc_Call) Run(run func(ctx context.Context, params *ec2.AttachClassicLinkVpcInput, optFns ...func(*ec2.Options))) *EC2_AttachClassicLinkVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AttachClassicLinkVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AttachClassicLinkVpc_Call) Return(_a0 *ec2.AttachClassicLinkVpcOutput, _a1 error) *EC2_AttachClassicLinkVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AttachClassicLinkVpc_Call) RunAndReturn(run func(context.Context, *ec2.AttachClassicLinkVpcInput, ...func(*ec2.Options)) (*ec2.AttachClassicLinkVpcOutput, error)) *EC2_AttachClassicLinkVpc_Call {
	_c.Call.Return(run)
	return _c
}

// AttachInternetGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AttachInternetGateway(ctx context.Context, params *ec2.AttachInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.AttachInternetGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AttachInternetGateway")
	}

	var r0 *ec2.AttachInternetGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachInternetGatewayInput, ...func(*ec2.Options)) (*ec2.AttachInternetGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachInternetGatewayInput, ...func(*ec2.Options)) *ec2.AttachInternetGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachInternetGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AttachInternetGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AttachInternetGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachInternetGateway'
type EC2_AttachInternetGateway_Call struct {
	*mock.Call
}

// AttachInternetGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AttachInternetGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AttachInternetGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AttachInternetGateway_Call {
	return &EC2_AttachInternetGateway_Call{Call: _e.mock.On("AttachInternetGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AttachInternetGateway_Call) Run(run func(ctx context.Context, params *ec2.AttachInternetGatewayInput, optFns ...func(*ec2.Options))) *EC2_AttachInternetGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AttachInternetGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AttachInternetGateway_Call) Return(_a0 *ec2.AttachInternetGatewayOutput, _a1 error) *EC2_AttachInternetGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AttachInternetGateway_Call) RunAndReturn(run func(context.Context, *ec2.AttachInternetGatewayInput, ...func(*ec2.Options)) (*ec2.AttachInternetGatewayOutput, error)) *EC2_AttachInternetGateway_Call {
	_c.Call.Return(run)
	return _c
}

// AttachNetworkInterface provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AttachNetworkInterface(ctx context.Context, params *ec2.AttachNetworkInterfaceInput, optFns ...func(*ec2.Options)) (*ec2.AttachNetworkInterfaceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AttachNetworkInterface")
	}

	var r0 *ec2.AttachNetworkInterfaceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachNetworkInterfaceInput, ...func(*ec2.Options)) (*ec2.AttachNetworkInterfaceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachNetworkInterfaceInput, ...func(*ec2.Options)) *ec2.AttachNetworkInterfaceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachNetworkInterfaceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AttachNetworkInterfaceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AttachNetworkInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachNetworkInterface'
type EC2_AttachNetworkInterface_Call struct {
	*mock.Call
}

// AttachNetworkInterface is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AttachNetworkInterfaceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AttachNetworkInterface(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AttachNetworkInterface_Call {
	return &EC2_AttachNetworkInterface_Call{Call: _e.mock.On("AttachNetworkInterface",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AttachNetworkInterface_Call) Run(run func(ctx context.Context, params *ec2.AttachNetworkInterfaceInput, optFns ...func(*ec2.Options))) *EC2_AttachNetworkInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AttachNetworkInterfaceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AttachNetworkInterface_Call) Return(_a0 *ec2.AttachNetworkInterfaceOutput, _a1 error) *EC2_AttachNetworkInterface_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AttachNetworkInterface_Call) RunAndReturn(run func(context.Context, *ec2.AttachNetworkInterfaceInput, ...func(*ec2.Options)) (*ec2.AttachNetworkInterfaceOutput, error)) *EC2_AttachNetworkInterface_Call {
	_c.Call.Return(run)
	return _c
}

// AttachVerifiedAccessTrustProvider provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AttachVerifiedAccessTrustProvider(ctx context.Context, params *ec2.AttachVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options)) (*ec2.AttachVerifiedAccessTrustProviderOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AttachVerifiedAccessTrustProvider")
	}

	var r0 *ec2.AttachVerifiedAccessTrustProviderOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.AttachVerifiedAccessTrustProviderOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) *ec2.AttachVerifiedAccessTrustProviderOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachVerifiedAccessTrustProviderOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AttachVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AttachVerifiedAccessTrustProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachVerifiedAccessTrustProvider'
type EC2_AttachVerifiedAccessTrustProvider_Call struct {
	*mock.Call
}

// AttachVerifiedAccessTrustProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AttachVerifiedAccessTrustProviderInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AttachVerifiedAccessTrustProvider(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AttachVerifiedAccessTrustProvider_Call {
	return &EC2_AttachVerifiedAccessTrustProvider_Call{Call: _e.mock.On("AttachVerifiedAccessTrustProvider",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AttachVerifiedAccessTrustProvider_Call) Run(run func(ctx context.Context, params *ec2.AttachVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options))) *EC2_AttachVerifiedAccessTrustProvider_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AttachVerifiedAccessTrustProviderInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AttachVerifiedAccessTrustProvider_Call) Return(_a0 *ec2.AttachVerifiedAccessTrustProviderOutput, _a1 error) *EC2_AttachVerifiedAccessTrustProvider_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AttachVerifiedAccessTrustProvider_Call) RunAndReturn(run func(context.Context, *ec2.AttachVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.AttachVerifiedAccessTrustProviderOutput, error)) *EC2_AttachVerifiedAccessTrustProvider_Call {
	_c.Call.Return(run)
	return _c
}

// AttachVolume provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AttachVolume(ctx context.Context, params *ec2.AttachVolumeInput, optFns ...func(*ec2.Options)) (*ec2.AttachVolumeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AttachVolume")
	}

	var r0 *ec2.AttachVolumeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachVolumeInput, ...func(*ec2.Options)) (*ec2.AttachVolumeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachVolumeInput, ...func(*ec2.Options)) *ec2.AttachVolumeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachVolumeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AttachVolumeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AttachVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachVolume'
type EC2_AttachVolume_Call struct {
	*mock.Call
}

// AttachVolume is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AttachVolumeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AttachVolume(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AttachVolume_Call {
	return &EC2_AttachVolume_Call{Call: _e.mock.On("AttachVolume",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AttachVolume_Call) Run(run func(ctx context.Context, params *ec2.AttachVolumeInput, optFns ...func(*ec2.Options))) *EC2_AttachVolume_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AttachVolumeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AttachVolume_Call) Return(_a0 *ec2.AttachVolumeOutput, _a1 error) *EC2_AttachVolume_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AttachVolume_Call) RunAndReturn(run func(context.Context, *ec2.AttachVolumeInput, ...func(*ec2.Options)) (*ec2.AttachVolumeOutput, error)) *EC2_AttachVolume_Call {
	_c.Call.Return(run)
	return _c
}

// AttachVpnGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AttachVpnGateway(ctx context.Context, params *ec2.AttachVpnGatewayInput, optFns ...func(*ec2.Options)) (*ec2.AttachVpnGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AttachVpnGateway")
	}

	var r0 *ec2.AttachVpnGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachVpnGatewayInput, ...func(*ec2.Options)) (*ec2.AttachVpnGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AttachVpnGatewayInput, ...func(*ec2.Options)) *ec2.AttachVpnGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AttachVpnGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AttachVpnGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AttachVpnGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttachVpnGateway'
type EC2_AttachVpnGateway_Call struct {
	*mock.Call
}

// AttachVpnGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AttachVpnGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AttachVpnGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AttachVpnGateway_Call {
	return &EC2_AttachVpnGateway_Call{Call: _e.mock.On("AttachVpnGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AttachVpnGateway_Call) Run(run func(ctx context.Context, params *ec2.AttachVpnGatewayInput, optFns ...func(*ec2.Options))) *EC2_AttachVpnGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AttachVpnGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AttachVpnGateway_Call) Return(_a0 *ec2.AttachVpnGatewayOutput, _a1 error) *EC2_AttachVpnGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AttachVpnGateway_Call) RunAndReturn(run func(context.Context, *ec2.AttachVpnGatewayInput, ...func(*ec2.Options)) (*ec2.AttachVpnGatewayOutput, error)) *EC2_AttachVpnGateway_Call {
	_c.Call.Return(run)
	return _c
}

// AuthorizeClientVpnIngress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AuthorizeClientVpnIngress(ctx context.Context, params *ec2.AuthorizeClientVpnIngressInput, optFns ...func(*ec2.Options)) (*ec2.AuthorizeClientVpnIngressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AuthorizeClientVpnIngress")
	}

	var r0 *ec2.AuthorizeClientVpnIngressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeClientVpnIngressInput, ...func(*ec2.Options)) (*ec2.AuthorizeClientVpnIngressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeClientVpnIngressInput, ...func(*ec2.Options)) *ec2.AuthorizeClientVpnIngressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeClientVpnIngressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AuthorizeClientVpnIngressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AuthorizeClientVpnIngress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizeClientVpnIngress'
type EC2_AuthorizeClientVpnIngress_Call struct {
	*mock.Call
}

// AuthorizeClientVpnIngress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AuthorizeClientVpnIngressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AuthorizeClientVpnIngress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AuthorizeClientVpnIngress_Call {
	return &EC2_AuthorizeClientVpnIngress_Call{Call: _e.mock.On("AuthorizeClientVpnIngress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AuthorizeClientVpnIngress_Call) Run(run func(ctx context.Context, params *ec2.AuthorizeClientVpnIngressInput, optFns ...func(*ec2.Options))) *EC2_AuthorizeClientVpnIngress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AuthorizeClientVpnIngressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AuthorizeClientVpnIngress_Call) Return(_a0 *ec2.AuthorizeClientVpnIngressOutput, _a1 error) *EC2_AuthorizeClientVpnIngress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AuthorizeClientVpnIngress_Call) RunAndReturn(run func(context.Context, *ec2.AuthorizeClientVpnIngressInput, ...func(*ec2.Options)) (*ec2.AuthorizeClientVpnIngressOutput, error)) *EC2_AuthorizeClientVpnIngress_Call {
	_c.Call.Return(run)
	return _c
}

// AuthorizeSecurityGroupEgress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AuthorizeSecurityGroupEgress(ctx context.Context, params *ec2.AuthorizeSecurityGroupEgressInput, optFns ...func(*ec2.Options)) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AuthorizeSecurityGroupEgress")
	}

	var r0 *ec2.AuthorizeSecurityGroupEgressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeSecurityGroupEgressInput, ...func(*ec2.Options)) (*ec2.AuthorizeSecurityGroupEgressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeSecurityGroupEgressInput, ...func(*ec2.Options)) *ec2.AuthorizeSecurityGroupEgressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeSecurityGroupEgressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AuthorizeSecurityGroupEgressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AuthorizeSecurityGroupEgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizeSecurityGroupEgress'
type EC2_AuthorizeSecurityGroupEgress_Call struct {
	*mock.Call
}

// AuthorizeSecurityGroupEgress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AuthorizeSecurityGroupEgressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AuthorizeSecurityGroupEgress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AuthorizeSecurityGroupEgress_Call {
	return &EC2_AuthorizeSecurityGroupEgress_Call{Call: _e.mock.On("AuthorizeSecurityGroupEgress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AuthorizeSecurityGroupEgress_Call) Run(run func(ctx context.Context, params *ec2.AuthorizeSecurityGroupEgressInput, optFns ...func(*ec2.Options))) *EC2_AuthorizeSecurityGroupEgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AuthorizeSecurityGroupEgressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AuthorizeSecurityGroupEgress_Call) Return(_a0 *ec2.AuthorizeSecurityGroupEgressOutput, _a1 error) *EC2_AuthorizeSecurityGroupEgress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AuthorizeSecurityGroupEgress_Call) RunAndReturn(run func(context.Context, *ec2.AuthorizeSecurityGroupEgressInput, ...func(*ec2.Options)) (*ec2.AuthorizeSecurityGroupEgressOutput, error)) *EC2_AuthorizeSecurityGroupEgress_Call {
	_c.Call.Return(run)
	return _c
}

// AuthorizeSecurityGroupIngress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) AuthorizeSecurityGroupIngress(ctx context.Context, params *ec2.AuthorizeSecurityGroupIngressInput, optFns ...func(*ec2.Options)) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AuthorizeSecurityGroupIngress")
	}

	var r0 *ec2.AuthorizeSecurityGroupIngressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeSecurityGroupIngressInput, ...func(*ec2.Options)) (*ec2.AuthorizeSecurityGroupIngressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.AuthorizeSecurityGroupIngressInput, ...func(*ec2.Options)) *ec2.AuthorizeSecurityGroupIngressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.AuthorizeSecurityGroupIngressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.AuthorizeSecurityGroupIngressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_AuthorizeSecurityGroupIngress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizeSecurityGroupIngress'
type EC2_AuthorizeSecurityGroupIngress_Call struct {
	*mock.Call
}

// AuthorizeSecurityGroupIngress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.AuthorizeSecurityGroupIngressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) AuthorizeSecurityGroupIngress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_AuthorizeSecurityGroupIngress_Call {
	return &EC2_AuthorizeSecurityGroupIngress_Call{Call: _e.mock.On("AuthorizeSecurityGroupIngress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_AuthorizeSecurityGroupIngress_Call) Run(run func(ctx context.Context, params *ec2.AuthorizeSecurityGroupIngressInput, optFns ...func(*ec2.Options))) *EC2_AuthorizeSecurityGroupIngress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.AuthorizeSecurityGroupIngressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_AuthorizeSecurityGroupIngress_Call) Return(_a0 *ec2.AuthorizeSecurityGroupIngressOutput, _a1 error) *EC2_AuthorizeSecurityGroupIngress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_AuthorizeSecurityGroupIngress_Call) RunAndReturn(run func(context.Context, *ec2.AuthorizeSecurityGroupIngressInput, ...func(*ec2.Options)) (*ec2.AuthorizeSecurityGroupIngressOutput, error)) *EC2_AuthorizeSecurityGroupIngress_Call {
	_c.Call.Return(run)
	return _c
}

// BundleInstance provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) BundleInstance(ctx context.Context, params *ec2.BundleInstanceInput, optFns ...func(*ec2.Options)) (*ec2.BundleInstanceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for BundleInstance")
	}

	var r0 *ec2.BundleInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.BundleInstanceInput, ...func(*ec2.Options)) (*ec2.BundleInstanceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.BundleInstanceInput, ...func(*ec2.Options)) *ec2.BundleInstanceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.BundleInstanceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.BundleInstanceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_BundleInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BundleInstance'
type EC2_BundleInstance_Call struct {
	*mock.Call
}

// BundleInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.BundleInstanceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) BundleInstance(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_BundleInstance_Call {
	return &EC2_BundleInstance_Call{Call: _e.mock.On("BundleInstance",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_BundleInstance_Call) Run(run func(ctx context.Context, params *ec2.BundleInstanceInput, optFns ...func(*ec2.Options))) *EC2_BundleInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.BundleInstanceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_BundleInstance_Call) Return(_a0 *ec2.BundleInstanceOutput, _a1 error) *EC2_BundleInstance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_BundleInstance_Call) RunAndReturn(run func(context.Context, *ec2.BundleInstanceInput, ...func(*ec2.Options)) (*ec2.BundleInstanceOutput, error)) *EC2_BundleInstance_Call {
	_c.Call.Return(run)
	return _c
}

// CancelBundleTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelBundleTask(ctx context.Context, params *ec2.CancelBundleTaskInput, optFns ...func(*ec2.Options)) (*ec2.CancelBundleTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelBundleTask")
	}

	var r0 *ec2.CancelBundleTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelBundleTaskInput, ...func(*ec2.Options)) (*ec2.CancelBundleTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelBundleTaskInput, ...func(*ec2.Options)) *ec2.CancelBundleTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelBundleTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelBundleTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelBundleTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelBundleTask'
type EC2_CancelBundleTask_Call struct {
	*mock.Call
}

// CancelBundleTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelBundleTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelBundleTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelBundleTask_Call {
	return &EC2_CancelBundleTask_Call{Call: _e.mock.On("CancelBundleTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelBundleTask_Call) Run(run func(ctx context.Context, params *ec2.CancelBundleTaskInput, optFns ...func(*ec2.Options))) *EC2_CancelBundleTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelBundleTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelBundleTask_Call) Return(_a0 *ec2.CancelBundleTaskOutput, _a1 error) *EC2_CancelBundleTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelBundleTask_Call) RunAndReturn(run func(context.Context, *ec2.CancelBundleTaskInput, ...func(*ec2.Options)) (*ec2.CancelBundleTaskOutput, error)) *EC2_CancelBundleTask_Call {
	_c.Call.Return(run)
	return _c
}

// CancelCapacityReservation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelCapacityReservation(ctx context.Context, params *ec2.CancelCapacityReservationInput, optFns ...func(*ec2.Options)) (*ec2.CancelCapacityReservationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelCapacityReservation")
	}

	var r0 *ec2.CancelCapacityReservationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelCapacityReservationInput, ...func(*ec2.Options)) (*ec2.CancelCapacityReservationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelCapacityReservationInput, ...func(*ec2.Options)) *ec2.CancelCapacityReservationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelCapacityReservationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelCapacityReservationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelCapacityReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelCapacityReservation'
type EC2_CancelCapacityReservation_Call struct {
	*mock.Call
}

// CancelCapacityReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelCapacityReservationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelCapacityReservation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelCapacityReservation_Call {
	return &EC2_CancelCapacityReservation_Call{Call: _e.mock.On("CancelCapacityReservation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelCapacityReservation_Call) Run(run func(ctx context.Context, params *ec2.CancelCapacityReservationInput, optFns ...func(*ec2.Options))) *EC2_CancelCapacityReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelCapacityReservationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelCapacityReservation_Call) Return(_a0 *ec2.CancelCapacityReservationOutput, _a1 error) *EC2_CancelCapacityReservation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelCapacityReservation_Call) RunAndReturn(run func(context.Context, *ec2.CancelCapacityReservationInput, ...func(*ec2.Options)) (*ec2.CancelCapacityReservationOutput, error)) *EC2_CancelCapacityReservation_Call {
	_c.Call.Return(run)
	return _c
}

// CancelCapacityReservationFleets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelCapacityReservationFleets(ctx context.Context, params *ec2.CancelCapacityReservationFleetsInput, optFns ...func(*ec2.Options)) (*ec2.CancelCapacityReservationFleetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelCapacityReservationFleets")
	}

	var r0 *ec2.CancelCapacityReservationFleetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelCapacityReservationFleetsInput, ...func(*ec2.Options)) (*ec2.CancelCapacityReservationFleetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelCapacityReservationFleetsInput, ...func(*ec2.Options)) *ec2.CancelCapacityReservationFleetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelCapacityReservationFleetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelCapacityReservationFleetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelCapacityReservationFleets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelCapacityReservationFleets'
type EC2_CancelCapacityReservationFleets_Call struct {
	*mock.Call
}

// CancelCapacityReservationFleets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelCapacityReservationFleetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelCapacityReservationFleets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelCapacityReservationFleets_Call {
	return &EC2_CancelCapacityReservationFleets_Call{Call: _e.mock.On("CancelCapacityReservationFleets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelCapacityReservationFleets_Call) Run(run func(ctx context.Context, params *ec2.CancelCapacityReservationFleetsInput, optFns ...func(*ec2.Options))) *EC2_CancelCapacityReservationFleets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelCapacityReservationFleetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelCapacityReservationFleets_Call) Return(_a0 *ec2.CancelCapacityReservationFleetsOutput, _a1 error) *EC2_CancelCapacityReservationFleets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelCapacityReservationFleets_Call) RunAndReturn(run func(context.Context, *ec2.CancelCapacityReservationFleetsInput, ...func(*ec2.Options)) (*ec2.CancelCapacityReservationFleetsOutput, error)) *EC2_CancelCapacityReservationFleets_Call {
	_c.Call.Return(run)
	return _c
}

// CancelConversionTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelConversionTask(ctx context.Context, params *ec2.CancelConversionTaskInput, optFns ...func(*ec2.Options)) (*ec2.CancelConversionTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelConversionTask")
	}

	var r0 *ec2.CancelConversionTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelConversionTaskInput, ...func(*ec2.Options)) (*ec2.CancelConversionTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelConversionTaskInput, ...func(*ec2.Options)) *ec2.CancelConversionTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelConversionTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelConversionTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelConversionTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelConversionTask'
type EC2_CancelConversionTask_Call struct {
	*mock.Call
}

// CancelConversionTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelConversionTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelConversionTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelConversionTask_Call {
	return &EC2_CancelConversionTask_Call{Call: _e.mock.On("CancelConversionTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelConversionTask_Call) Run(run func(ctx context.Context, params *ec2.CancelConversionTaskInput, optFns ...func(*ec2.Options))) *EC2_CancelConversionTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelConversionTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelConversionTask_Call) Return(_a0 *ec2.CancelConversionTaskOutput, _a1 error) *EC2_CancelConversionTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelConversionTask_Call) RunAndReturn(run func(context.Context, *ec2.CancelConversionTaskInput, ...func(*ec2.Options)) (*ec2.CancelConversionTaskOutput, error)) *EC2_CancelConversionTask_Call {
	_c.Call.Return(run)
	return _c
}

// CancelDeclarativePoliciesReport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelDeclarativePoliciesReport(ctx context.Context, params *ec2.CancelDeclarativePoliciesReportInput, optFns ...func(*ec2.Options)) (*ec2.CancelDeclarativePoliciesReportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelDeclarativePoliciesReport")
	}

	var r0 *ec2.CancelDeclarativePoliciesReportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelDeclarativePoliciesReportInput, ...func(*ec2.Options)) (*ec2.CancelDeclarativePoliciesReportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelDeclarativePoliciesReportInput, ...func(*ec2.Options)) *ec2.CancelDeclarativePoliciesReportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelDeclarativePoliciesReportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelDeclarativePoliciesReportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelDeclarativePoliciesReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelDeclarativePoliciesReport'
type EC2_CancelDeclarativePoliciesReport_Call struct {
	*mock.Call
}

// CancelDeclarativePoliciesReport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelDeclarativePoliciesReportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelDeclarativePoliciesReport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelDeclarativePoliciesReport_Call {
	return &EC2_CancelDeclarativePoliciesReport_Call{Call: _e.mock.On("CancelDeclarativePoliciesReport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelDeclarativePoliciesReport_Call) Run(run func(ctx context.Context, params *ec2.CancelDeclarativePoliciesReportInput, optFns ...func(*ec2.Options))) *EC2_CancelDeclarativePoliciesReport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelDeclarativePoliciesReportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelDeclarativePoliciesReport_Call) Return(_a0 *ec2.CancelDeclarativePoliciesReportOutput, _a1 error) *EC2_CancelDeclarativePoliciesReport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelDeclarativePoliciesReport_Call) RunAndReturn(run func(context.Context, *ec2.CancelDeclarativePoliciesReportInput, ...func(*ec2.Options)) (*ec2.CancelDeclarativePoliciesReportOutput, error)) *EC2_CancelDeclarativePoliciesReport_Call {
	_c.Call.Return(run)
	return _c
}

// CancelExportTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelExportTask(ctx context.Context, params *ec2.CancelExportTaskInput, optFns ...func(*ec2.Options)) (*ec2.CancelExportTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelExportTask")
	}

	var r0 *ec2.CancelExportTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelExportTaskInput, ...func(*ec2.Options)) (*ec2.CancelExportTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelExportTaskInput, ...func(*ec2.Options)) *ec2.CancelExportTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelExportTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelExportTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelExportTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelExportTask'
type EC2_CancelExportTask_Call struct {
	*mock.Call
}

// CancelExportTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelExportTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelExportTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelExportTask_Call {
	return &EC2_CancelExportTask_Call{Call: _e.mock.On("CancelExportTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelExportTask_Call) Run(run func(ctx context.Context, params *ec2.CancelExportTaskInput, optFns ...func(*ec2.Options))) *EC2_CancelExportTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelExportTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelExportTask_Call) Return(_a0 *ec2.CancelExportTaskOutput, _a1 error) *EC2_CancelExportTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelExportTask_Call) RunAndReturn(run func(context.Context, *ec2.CancelExportTaskInput, ...func(*ec2.Options)) (*ec2.CancelExportTaskOutput, error)) *EC2_CancelExportTask_Call {
	_c.Call.Return(run)
	return _c
}

// CancelImageLaunchPermission provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelImageLaunchPermission(ctx context.Context, params *ec2.CancelImageLaunchPermissionInput, optFns ...func(*ec2.Options)) (*ec2.CancelImageLaunchPermissionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelImageLaunchPermission")
	}

	var r0 *ec2.CancelImageLaunchPermissionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelImageLaunchPermissionInput, ...func(*ec2.Options)) (*ec2.CancelImageLaunchPermissionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelImageLaunchPermissionInput, ...func(*ec2.Options)) *ec2.CancelImageLaunchPermissionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelImageLaunchPermissionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelImageLaunchPermissionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelImageLaunchPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelImageLaunchPermission'
type EC2_CancelImageLaunchPermission_Call struct {
	*mock.Call
}

// CancelImageLaunchPermission is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelImageLaunchPermissionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelImageLaunchPermission(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelImageLaunchPermission_Call {
	return &EC2_CancelImageLaunchPermission_Call{Call: _e.mock.On("CancelImageLaunchPermission",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelImageLaunchPermission_Call) Run(run func(ctx context.Context, params *ec2.CancelImageLaunchPermissionInput, optFns ...func(*ec2.Options))) *EC2_CancelImageLaunchPermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelImageLaunchPermissionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelImageLaunchPermission_Call) Return(_a0 *ec2.CancelImageLaunchPermissionOutput, _a1 error) *EC2_CancelImageLaunchPermission_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelImageLaunchPermission_Call) RunAndReturn(run func(context.Context, *ec2.CancelImageLaunchPermissionInput, ...func(*ec2.Options)) (*ec2.CancelImageLaunchPermissionOutput, error)) *EC2_CancelImageLaunchPermission_Call {
	_c.Call.Return(run)
	return _c
}

// CancelImportTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelImportTask(ctx context.Context, params *ec2.CancelImportTaskInput, optFns ...func(*ec2.Options)) (*ec2.CancelImportTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelImportTask")
	}

	var r0 *ec2.CancelImportTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelImportTaskInput, ...func(*ec2.Options)) (*ec2.CancelImportTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelImportTaskInput, ...func(*ec2.Options)) *ec2.CancelImportTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelImportTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelImportTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelImportTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelImportTask'
type EC2_CancelImportTask_Call struct {
	*mock.Call
}

// CancelImportTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelImportTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelImportTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelImportTask_Call {
	return &EC2_CancelImportTask_Call{Call: _e.mock.On("CancelImportTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelImportTask_Call) Run(run func(ctx context.Context, params *ec2.CancelImportTaskInput, optFns ...func(*ec2.Options))) *EC2_CancelImportTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelImportTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelImportTask_Call) Return(_a0 *ec2.CancelImportTaskOutput, _a1 error) *EC2_CancelImportTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelImportTask_Call) RunAndReturn(run func(context.Context, *ec2.CancelImportTaskInput, ...func(*ec2.Options)) (*ec2.CancelImportTaskOutput, error)) *EC2_CancelImportTask_Call {
	_c.Call.Return(run)
	return _c
}

// CancelReservedInstancesListing provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelReservedInstancesListing(ctx context.Context, params *ec2.CancelReservedInstancesListingInput, optFns ...func(*ec2.Options)) (*ec2.CancelReservedInstancesListingOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelReservedInstancesListing")
	}

	var r0 *ec2.CancelReservedInstancesListingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelReservedInstancesListingInput, ...func(*ec2.Options)) (*ec2.CancelReservedInstancesListingOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelReservedInstancesListingInput, ...func(*ec2.Options)) *ec2.CancelReservedInstancesListingOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelReservedInstancesListingOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelReservedInstancesListingInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelReservedInstancesListing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelReservedInstancesListing'
type EC2_CancelReservedInstancesListing_Call struct {
	*mock.Call
}

// CancelReservedInstancesListing is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelReservedInstancesListingInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelReservedInstancesListing(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelReservedInstancesListing_Call {
	return &EC2_CancelReservedInstancesListing_Call{Call: _e.mock.On("CancelReservedInstancesListing",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelReservedInstancesListing_Call) Run(run func(ctx context.Context, params *ec2.CancelReservedInstancesListingInput, optFns ...func(*ec2.Options))) *EC2_CancelReservedInstancesListing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelReservedInstancesListingInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelReservedInstancesListing_Call) Return(_a0 *ec2.CancelReservedInstancesListingOutput, _a1 error) *EC2_CancelReservedInstancesListing_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelReservedInstancesListing_Call) RunAndReturn(run func(context.Context, *ec2.CancelReservedInstancesListingInput, ...func(*ec2.Options)) (*ec2.CancelReservedInstancesListingOutput, error)) *EC2_CancelReservedInstancesListing_Call {
	_c.Call.Return(run)
	return _c
}

// CancelSpotFleetRequests provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelSpotFleetRequests(ctx context.Context, params *ec2.CancelSpotFleetRequestsInput, optFns ...func(*ec2.Options)) (*ec2.CancelSpotFleetRequestsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelSpotFleetRequests")
	}

	var r0 *ec2.CancelSpotFleetRequestsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelSpotFleetRequestsInput, ...func(*ec2.Options)) (*ec2.CancelSpotFleetRequestsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelSpotFleetRequestsInput, ...func(*ec2.Options)) *ec2.CancelSpotFleetRequestsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelSpotFleetRequestsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelSpotFleetRequestsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelSpotFleetRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelSpotFleetRequests'
type EC2_CancelSpotFleetRequests_Call struct {
	*mock.Call
}

// CancelSpotFleetRequests is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelSpotFleetRequestsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelSpotFleetRequests(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelSpotFleetRequests_Call {
	return &EC2_CancelSpotFleetRequests_Call{Call: _e.mock.On("CancelSpotFleetRequests",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelSpotFleetRequests_Call) Run(run func(ctx context.Context, params *ec2.CancelSpotFleetRequestsInput, optFns ...func(*ec2.Options))) *EC2_CancelSpotFleetRequests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelSpotFleetRequestsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelSpotFleetRequests_Call) Return(_a0 *ec2.CancelSpotFleetRequestsOutput, _a1 error) *EC2_CancelSpotFleetRequests_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelSpotFleetRequests_Call) RunAndReturn(run func(context.Context, *ec2.CancelSpotFleetRequestsInput, ...func(*ec2.Options)) (*ec2.CancelSpotFleetRequestsOutput, error)) *EC2_CancelSpotFleetRequests_Call {
	_c.Call.Return(run)
	return _c
}

// CancelSpotInstanceRequests provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CancelSpotInstanceRequests(ctx context.Context, params *ec2.CancelSpotInstanceRequestsInput, optFns ...func(*ec2.Options)) (*ec2.CancelSpotInstanceRequestsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelSpotInstanceRequests")
	}

	var r0 *ec2.CancelSpotInstanceRequestsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelSpotInstanceRequestsInput, ...func(*ec2.Options)) (*ec2.CancelSpotInstanceRequestsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CancelSpotInstanceRequestsInput, ...func(*ec2.Options)) *ec2.CancelSpotInstanceRequestsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CancelSpotInstanceRequestsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CancelSpotInstanceRequestsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CancelSpotInstanceRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelSpotInstanceRequests'
type EC2_CancelSpotInstanceRequests_Call struct {
	*mock.Call
}

// CancelSpotInstanceRequests is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CancelSpotInstanceRequestsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CancelSpotInstanceRequests(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CancelSpotInstanceRequests_Call {
	return &EC2_CancelSpotInstanceRequests_Call{Call: _e.mock.On("CancelSpotInstanceRequests",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CancelSpotInstanceRequests_Call) Run(run func(ctx context.Context, params *ec2.CancelSpotInstanceRequestsInput, optFns ...func(*ec2.Options))) *EC2_CancelSpotInstanceRequests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CancelSpotInstanceRequestsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CancelSpotInstanceRequests_Call) Return(_a0 *ec2.CancelSpotInstanceRequestsOutput, _a1 error) *EC2_CancelSpotInstanceRequests_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CancelSpotInstanceRequests_Call) RunAndReturn(run func(context.Context, *ec2.CancelSpotInstanceRequestsInput, ...func(*ec2.Options)) (*ec2.CancelSpotInstanceRequestsOutput, error)) *EC2_CancelSpotInstanceRequests_Call {
	_c.Call.Return(run)
	return _c
}

// ConfirmProductInstance provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ConfirmProductInstance(ctx context.Context, params *ec2.ConfirmProductInstanceInput, optFns ...func(*ec2.Options)) (*ec2.ConfirmProductInstanceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ConfirmProductInstance")
	}

	var r0 *ec2.ConfirmProductInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ConfirmProductInstanceInput, ...func(*ec2.Options)) (*ec2.ConfirmProductInstanceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ConfirmProductInstanceInput, ...func(*ec2.Options)) *ec2.ConfirmProductInstanceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ConfirmProductInstanceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ConfirmProductInstanceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ConfirmProductInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfirmProductInstance'
type EC2_ConfirmProductInstance_Call struct {
	*mock.Call
}

// ConfirmProductInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ConfirmProductInstanceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ConfirmProductInstance(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ConfirmProductInstance_Call {
	return &EC2_ConfirmProductInstance_Call{Call: _e.mock.On("ConfirmProductInstance",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ConfirmProductInstance_Call) Run(run func(ctx context.Context, params *ec2.ConfirmProductInstanceInput, optFns ...func(*ec2.Options))) *EC2_ConfirmProductInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ConfirmProductInstanceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ConfirmProductInstance_Call) Return(_a0 *ec2.ConfirmProductInstanceOutput, _a1 error) *EC2_ConfirmProductInstance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ConfirmProductInstance_Call) RunAndReturn(run func(context.Context, *ec2.ConfirmProductInstanceInput, ...func(*ec2.Options)) (*ec2.ConfirmProductInstanceOutput, error)) *EC2_ConfirmProductInstance_Call {
	_c.Call.Return(run)
	return _c
}

// CopyFpgaImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CopyFpgaImage(ctx context.Context, params *ec2.CopyFpgaImageInput, optFns ...func(*ec2.Options)) (*ec2.CopyFpgaImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CopyFpgaImage")
	}

	var r0 *ec2.CopyFpgaImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopyFpgaImageInput, ...func(*ec2.Options)) (*ec2.CopyFpgaImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopyFpgaImageInput, ...func(*ec2.Options)) *ec2.CopyFpgaImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopyFpgaImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CopyFpgaImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CopyFpgaImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyFpgaImage'
type EC2_CopyFpgaImage_Call struct {
	*mock.Call
}

// CopyFpgaImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CopyFpgaImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CopyFpgaImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CopyFpgaImage_Call {
	return &EC2_CopyFpgaImage_Call{Call: _e.mock.On("CopyFpgaImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CopyFpgaImage_Call) Run(run func(ctx context.Context, params *ec2.CopyFpgaImageInput, optFns ...func(*ec2.Options))) *EC2_CopyFpgaImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CopyFpgaImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CopyFpgaImage_Call) Return(_a0 *ec2.CopyFpgaImageOutput, _a1 error) *EC2_CopyFpgaImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CopyFpgaImage_Call) RunAndReturn(run func(context.Context, *ec2.CopyFpgaImageInput, ...func(*ec2.Options)) (*ec2.CopyFpgaImageOutput, error)) *EC2_CopyFpgaImage_Call {
	_c.Call.Return(run)
	return _c
}

// CopyImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CopyImage(ctx context.Context, params *ec2.CopyImageInput, optFns ...func(*ec2.Options)) (*ec2.CopyImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CopyImage")
	}

	var r0 *ec2.CopyImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopyImageInput, ...func(*ec2.Options)) (*ec2.CopyImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopyImageInput, ...func(*ec2.Options)) *ec2.CopyImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopyImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CopyImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CopyImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyImage'
type EC2_CopyImage_Call struct {
	*mock.Call
}

// CopyImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CopyImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CopyImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CopyImage_Call {
	return &EC2_CopyImage_Call{Call: _e.mock.On("CopyImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CopyImage_Call) Run(run func(ctx context.Context, params *ec2.CopyImageInput, optFns ...func(*ec2.Options))) *EC2_CopyImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CopyImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CopyImage_Call) Return(_a0 *ec2.CopyImageOutput, _a1 error) *EC2_CopyImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CopyImage_Call) RunAndReturn(run func(context.Context, *ec2.CopyImageInput, ...func(*ec2.Options)) (*ec2.CopyImageOutput, error)) *EC2_CopyImage_Call {
	_c.Call.Return(run)
	return _c
}

// CopySnapshot provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CopySnapshot(ctx context.Context, params *ec2.CopySnapshotInput, optFns ...func(*ec2.Options)) (*ec2.CopySnapshotOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CopySnapshot")
	}

	var r0 *ec2.CopySnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopySnapshotInput, ...func(*ec2.Options)) (*ec2.CopySnapshotOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopySnapshotInput, ...func(*ec2.Options)) *ec2.CopySnapshotOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopySnapshotOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CopySnapshotInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CopySnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopySnapshot'
type EC2_CopySnapshot_Call struct {
	*mock.Call
}

// CopySnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CopySnapshotInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CopySnapshot(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CopySnapshot_Call {
	return &EC2_CopySnapshot_Call{Call: _e.mock.On("CopySnapshot",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CopySnapshot_Call) Run(run func(ctx context.Context, params *ec2.CopySnapshotInput, optFns ...func(*ec2.Options))) *EC2_CopySnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CopySnapshotInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CopySnapshot_Call) Return(_a0 *ec2.CopySnapshotOutput, _a1 error) *EC2_CopySnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CopySnapshot_Call) RunAndReturn(run func(context.Context, *ec2.CopySnapshotInput, ...func(*ec2.Options)) (*ec2.CopySnapshotOutput, error)) *EC2_CopySnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// CopyVolumes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CopyVolumes(ctx context.Context, params *ec2.CopyVolumesInput, optFns ...func(*ec2.Options)) (*ec2.CopyVolumesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CopyVolumes")
	}

	var r0 *ec2.CopyVolumesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopyVolumesInput, ...func(*ec2.Options)) (*ec2.CopyVolumesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CopyVolumesInput, ...func(*ec2.Options)) *ec2.CopyVolumesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CopyVolumesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CopyVolumesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CopyVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyVolumes'
type EC2_CopyVolumes_Call struct {
	*mock.Call
}

// CopyVolumes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CopyVolumesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CopyVolumes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CopyVolumes_Call {
	return &EC2_CopyVolumes_Call{Call: _e.mock.On("CopyVolumes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CopyVolumes_Call) Run(run func(ctx context.Context, params *ec2.CopyVolumesInput, optFns ...func(*ec2.Options))) *EC2_CopyVolumes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CopyVolumesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CopyVolumes_Call) Return(_a0 *ec2.CopyVolumesOutput, _a1 error) *EC2_CopyVolumes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CopyVolumes_Call) RunAndReturn(run func(context.Context, *ec2.CopyVolumesInput, ...func(*ec2.Options)) (*ec2.CopyVolumesOutput, error)) *EC2_CopyVolumes_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCapacityManagerDataExport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateCapacityManagerDataExport(ctx context.Context, params *ec2.CreateCapacityManagerDataExportInput, optFns ...func(*ec2.Options)) (*ec2.CreateCapacityManagerDataExportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateCapacityManagerDataExport")
	}

	var r0 *ec2.CreateCapacityManagerDataExportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityManagerDataExportInput, ...func(*ec2.Options)) (*ec2.CreateCapacityManagerDataExportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityManagerDataExportInput, ...func(*ec2.Options)) *ec2.CreateCapacityManagerDataExportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCapacityManagerDataExportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateCapacityManagerDataExportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateCapacityManagerDataExport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCapacityManagerDataExport'
type EC2_CreateCapacityManagerDataExport_Call struct {
	*mock.Call
}

// CreateCapacityManagerDataExport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateCapacityManagerDataExportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateCapacityManagerDataExport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateCapacityManagerDataExport_Call {
	return &EC2_CreateCapacityManagerDataExport_Call{Call: _e.mock.On("CreateCapacityManagerDataExport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateCapacityManagerDataExport_Call) Run(run func(ctx context.Context, params *ec2.CreateCapacityManagerDataExportInput, optFns ...func(*ec2.Options))) *EC2_CreateCapacityManagerDataExport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateCapacityManagerDataExportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateCapacityManagerDataExport_Call) Return(_a0 *ec2.CreateCapacityManagerDataExportOutput, _a1 error) *EC2_CreateCapacityManagerDataExport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateCapacityManagerDataExport_Call) RunAndReturn(run func(context.Context, *ec2.CreateCapacityManagerDataExportInput, ...func(*ec2.Options)) (*ec2.CreateCapacityManagerDataExportOutput, error)) *EC2_CreateCapacityManagerDataExport_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCapacityReservation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateCapacityReservation(ctx context.Context, params *ec2.CreateCapacityReservationInput, optFns ...func(*ec2.Options)) (*ec2.CreateCapacityReservationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateCapacityReservation")
	}

	var r0 *ec2.CreateCapacityReservationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityReservationInput, ...func(*ec2.Options)) (*ec2.CreateCapacityReservationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityReservationInput, ...func(*ec2.Options)) *ec2.CreateCapacityReservationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCapacityReservationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateCapacityReservationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateCapacityReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCapacityReservation'
type EC2_CreateCapacityReservation_Call struct {
	*mock.Call
}

// CreateCapacityReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateCapacityReservationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateCapacityReservation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateCapacityReservation_Call {
	return &EC2_CreateCapacityReservation_Call{Call: _e.mock.On("CreateCapacityReservation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateCapacityReservation_Call) Run(run func(ctx context.Context, params *ec2.CreateCapacityReservationInput, optFns ...func(*ec2.Options))) *EC2_CreateCapacityReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateCapacityReservationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateCapacityReservation_Call) Return(_a0 *ec2.CreateCapacityReservationOutput, _a1 error) *EC2_CreateCapacityReservation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateCapacityReservation_Call) RunAndReturn(run func(context.Context, *ec2.CreateCapacityReservationInput, ...func(*ec2.Options)) (*ec2.CreateCapacityReservationOutput, error)) *EC2_CreateCapacityReservation_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCapacityReservationBySplitting provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateCapacityReservationBySplitting(ctx context.Context, params *ec2.CreateCapacityReservationBySplittingInput, optFns ...func(*ec2.Options)) (*ec2.CreateCapacityReservationBySplittingOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateCapacityReservationBySplitting")
	}

	var r0 *ec2.CreateCapacityReservationBySplittingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityReservationBySplittingInput, ...func(*ec2.Options)) (*ec2.CreateCapacityReservationBySplittingOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityReservationBySplittingInput, ...func(*ec2.Options)) *ec2.CreateCapacityReservationBySplittingOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCapacityReservationBySplittingOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateCapacityReservationBySplittingInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateCapacityReservationBySplitting_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCapacityReservationBySplitting'
type EC2_CreateCapacityReservationBySplitting_Call struct {
	*mock.Call
}

// CreateCapacityReservationBySplitting is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateCapacityReservationBySplittingInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateCapacityReservationBySplitting(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateCapacityReservationBySplitting_Call {
	return &EC2_CreateCapacityReservationBySplitting_Call{Call: _e.mock.On("CreateCapacityReservationBySplitting",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateCapacityReservationBySplitting_Call) Run(run func(ctx context.Context, params *ec2.CreateCapacityReservationBySplittingInput, optFns ...func(*ec2.Options))) *EC2_CreateCapacityReservationBySplitting_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateCapacityReservationBySplittingInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateCapacityReservationBySplitting_Call) Return(_a0 *ec2.CreateCapacityReservationBySplittingOutput, _a1 error) *EC2_CreateCapacityReservationBySplitting_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateCapacityReservationBySplitting_Call) RunAndReturn(run func(context.Context, *ec2.CreateCapacityReservationBySplittingInput, ...func(*ec2.Options)) (*ec2.CreateCapacityReservationBySplittingOutput, error)) *EC2_CreateCapacityReservationBySplitting_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCapacityReservationFleet provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateCapacityReservationFleet(ctx context.Context, params *ec2.CreateCapacityReservationFleetInput, optFns ...func(*ec2.Options)) (*ec2.CreateCapacityReservationFleetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateCapacityReservationFleet")
	}

	var r0 *ec2.CreateCapacityReservationFleetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityReservationFleetInput, ...func(*ec2.Options)) (*ec2.CreateCapacityReservationFleetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCapacityReservationFleetInput, ...func(*ec2.Options)) *ec2.CreateCapacityReservationFleetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCapacityReservationFleetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateCapacityReservationFleetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateCapacityReservationFleet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCapacityReservationFleet'
type EC2_CreateCapacityReservationFleet_Call struct {
	*mock.Call
}

// CreateCapacityReservationFleet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateCapacityReservationFleetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateCapacityReservationFleet(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateCapacityReservationFleet_Call {
	return &EC2_CreateCapacityReservationFleet_Call{Call: _e.mock.On("CreateCapacityReservationFleet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateCapacityReservationFleet_Call) Run(run func(ctx context.Context, params *ec2.CreateCapacityReservationFleetInput, optFns ...func(*ec2.Options))) *EC2_CreateCapacityReservationFleet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateCapacityReservationFleetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateCapacityReservationFleet_Call) Return(_a0 *ec2.CreateCapacityReservationFleetOutput, _a1 error) *EC2_CreateCapacityReservationFleet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateCapacityReservationFleet_Call) RunAndReturn(run func(context.Context, *ec2.CreateCapacityReservationFleetInput, ...func(*ec2.Options)) (*ec2.CreateCapacityReservationFleetOutput, error)) *EC2_CreateCapacityReservationFleet_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCarrierGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateCarrierGateway(ctx context.Context, params *ec2.CreateCarrierGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateCarrierGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateCarrierGateway")
	}

	var r0 *ec2.CreateCarrierGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCarrierGatewayInput, ...func(*ec2.Options)) (*ec2.CreateCarrierGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCarrierGatewayInput, ...func(*ec2.Options)) *ec2.CreateCarrierGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCarrierGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateCarrierGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateCarrierGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCarrierGateway'
type EC2_CreateCarrierGateway_Call struct {
	*mock.Call
}

// CreateCarrierGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateCarrierGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateCarrierGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateCarrierGateway_Call {
	return &EC2_CreateCarrierGateway_Call{Call: _e.mock.On("CreateCarrierGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateCarrierGateway_Call) Run(run func(ctx context.Context, params *ec2.CreateCarrierGatewayInput, optFns ...func(*ec2.Options))) *EC2_CreateCarrierGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateCarrierGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateCarrierGateway_Call) Return(_a0 *ec2.CreateCarrierGatewayOutput, _a1 error) *EC2_CreateCarrierGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateCarrierGateway_Call) RunAndReturn(run func(context.Context, *ec2.CreateCarrierGatewayInput, ...func(*ec2.Options)) (*ec2.CreateCarrierGatewayOutput, error)) *EC2_CreateCarrierGateway_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClientVpnEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateClientVpnEndpoint(ctx context.Context, params *ec2.CreateClientVpnEndpointInput, optFns ...func(*ec2.Options)) (*ec2.CreateClientVpnEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateClientVpnEndpoint")
	}

	var r0 *ec2.CreateClientVpnEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateClientVpnEndpointInput, ...func(*ec2.Options)) (*ec2.CreateClientVpnEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateClientVpnEndpointInput, ...func(*ec2.Options)) *ec2.CreateClientVpnEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateClientVpnEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateClientVpnEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateClientVpnEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClientVpnEndpoint'
type EC2_CreateClientVpnEndpoint_Call struct {
	*mock.Call
}

// CreateClientVpnEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateClientVpnEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateClientVpnEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateClientVpnEndpoint_Call {
	return &EC2_CreateClientVpnEndpoint_Call{Call: _e.mock.On("CreateClientVpnEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateClientVpnEndpoint_Call) Run(run func(ctx context.Context, params *ec2.CreateClientVpnEndpointInput, optFns ...func(*ec2.Options))) *EC2_CreateClientVpnEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateClientVpnEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateClientVpnEndpoint_Call) Return(_a0 *ec2.CreateClientVpnEndpointOutput, _a1 error) *EC2_CreateClientVpnEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateClientVpnEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.CreateClientVpnEndpointInput, ...func(*ec2.Options)) (*ec2.CreateClientVpnEndpointOutput, error)) *EC2_CreateClientVpnEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClientVpnRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateClientVpnRoute(ctx context.Context, params *ec2.CreateClientVpnRouteInput, optFns ...func(*ec2.Options)) (*ec2.CreateClientVpnRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateClientVpnRoute")
	}

	var r0 *ec2.CreateClientVpnRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateClientVpnRouteInput, ...func(*ec2.Options)) (*ec2.CreateClientVpnRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateClientVpnRouteInput, ...func(*ec2.Options)) *ec2.CreateClientVpnRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateClientVpnRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateClientVpnRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateClientVpnRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClientVpnRoute'
type EC2_CreateClientVpnRoute_Call struct {
	*mock.Call
}

// CreateClientVpnRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateClientVpnRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateClientVpnRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateClientVpnRoute_Call {
	return &EC2_CreateClientVpnRoute_Call{Call: _e.mock.On("CreateClientVpnRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateClientVpnRoute_Call) Run(run func(ctx context.Context, params *ec2.CreateClientVpnRouteInput, optFns ...func(*ec2.Options))) *EC2_CreateClientVpnRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateClientVpnRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateClientVpnRoute_Call) Return(_a0 *ec2.CreateClientVpnRouteOutput, _a1 error) *EC2_CreateClientVpnRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateClientVpnRoute_Call) RunAndReturn(run func(context.Context, *ec2.CreateClientVpnRouteInput, ...func(*ec2.Options)) (*ec2.CreateClientVpnRouteOutput, error)) *EC2_CreateClientVpnRoute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCoipCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateCoipCidr(ctx context.Context, params *ec2.CreateCoipCidrInput, optFns ...func(*ec2.Options)) (*ec2.CreateCoipCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateCoipCidr")
	}

	var r0 *ec2.CreateCoipCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCoipCidrInput, ...func(*ec2.Options)) (*ec2.CreateCoipCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCoipCidrInput, ...func(*ec2.Options)) *ec2.CreateCoipCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCoipCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateCoipCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateCoipCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCoipCidr'
type EC2_CreateCoipCidr_Call struct {
	*mock.Call
}

// CreateCoipCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateCoipCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateCoipCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateCoipCidr_Call {
	return &EC2_CreateCoipCidr_Call{Call: _e.mock.On("CreateCoipCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateCoipCidr_Call) Run(run func(ctx context.Context, params *ec2.CreateCoipCidrInput, optFns ...func(*ec2.Options))) *EC2_CreateCoipCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateCoipCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateCoipCidr_Call) Return(_a0 *ec2.CreateCoipCidrOutput, _a1 error) *EC2_CreateCoipCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateCoipCidr_Call) RunAndReturn(run func(context.Context, *ec2.CreateCoipCidrInput, ...func(*ec2.Options)) (*ec2.CreateCoipCidrOutput, error)) *EC2_CreateCoipCidr_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCoipPool provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateCoipPool(ctx context.Context, params *ec2.CreateCoipPoolInput, optFns ...func(*ec2.Options)) (*ec2.CreateCoipPoolOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateCoipPool")
	}

	var r0 *ec2.CreateCoipPoolOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCoipPoolInput, ...func(*ec2.Options)) (*ec2.CreateCoipPoolOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCoipPoolInput, ...func(*ec2.Options)) *ec2.CreateCoipPoolOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCoipPoolOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateCoipPoolInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateCoipPool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCoipPool'
type EC2_CreateCoipPool_Call struct {
	*mock.Call
}

// CreateCoipPool is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateCoipPoolInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateCoipPool(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateCoipPool_Call {
	return &EC2_CreateCoipPool_Call{Call: _e.mock.On("CreateCoipPool",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateCoipPool_Call) Run(run func(ctx context.Context, params *ec2.CreateCoipPoolInput, optFns ...func(*ec2.Options))) *EC2_CreateCoipPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateCoipPoolInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateCoipPool_Call) Return(_a0 *ec2.CreateCoipPoolOutput, _a1 error) *EC2_CreateCoipPool_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateCoipPool_Call) RunAndReturn(run func(context.Context, *ec2.CreateCoipPoolInput, ...func(*ec2.Options)) (*ec2.CreateCoipPoolOutput, error)) *EC2_CreateCoipPool_Call {
	_c.Call.Return(run)
	return _c
}

// CreateCustomerGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateCustomerGateway(ctx context.Context, params *ec2.CreateCustomerGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateCustomerGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateCustomerGateway")
	}

	var r0 *ec2.CreateCustomerGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCustomerGatewayInput, ...func(*ec2.Options)) (*ec2.CreateCustomerGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateCustomerGatewayInput, ...func(*ec2.Options)) *ec2.CreateCustomerGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateCustomerGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateCustomerGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateCustomerGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCustomerGateway'
type EC2_CreateCustomerGateway_Call struct {
	*mock.Call
}

// CreateCustomerGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateCustomerGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateCustomerGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateCustomerGateway_Call {
	return &EC2_CreateCustomerGateway_Call{Call: _e.mock.On("CreateCustomerGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateCustomerGateway_Call) Run(run func(ctx context.Context, params *ec2.CreateCustomerGatewayInput, optFns ...func(*ec2.Options))) *EC2_CreateCustomerGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateCustomerGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateCustomerGateway_Call) Return(_a0 *ec2.CreateCustomerGatewayOutput, _a1 error) *EC2_CreateCustomerGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateCustomerGateway_Call) RunAndReturn(run func(context.Context, *ec2.CreateCustomerGatewayInput, ...func(*ec2.Options)) (*ec2.CreateCustomerGatewayOutput, error)) *EC2_CreateCustomerGateway_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDefaultSubnet provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateDefaultSubnet(ctx context.Context, params *ec2.CreateDefaultSubnetInput, optFns ...func(*ec2.Options)) (*ec2.CreateDefaultSubnetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateDefaultSubnet")
	}

	var r0 *ec2.CreateDefaultSubnetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDefaultSubnetInput, ...func(*ec2.Options)) (*ec2.CreateDefaultSubnetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDefaultSubnetInput, ...func(*ec2.Options)) *ec2.CreateDefaultSubnetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDefaultSubnetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateDefaultSubnetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateDefaultSubnet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDefaultSubnet'
type EC2_CreateDefaultSubnet_Call struct {
	*mock.Call
}

// CreateDefaultSubnet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateDefaultSubnetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateDefaultSubnet(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateDefaultSubnet_Call {
	return &EC2_CreateDefaultSubnet_Call{Call: _e.mock.On("CreateDefaultSubnet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateDefaultSubnet_Call) Run(run func(ctx context.Context, params *ec2.CreateDefaultSubnetInput, optFns ...func(*ec2.Options))) *EC2_CreateDefaultSubnet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateDefaultSubnetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateDefaultSubnet_Call) Return(_a0 *ec2.CreateDefaultSubnetOutput, _a1 error) *EC2_CreateDefaultSubnet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateDefaultSubnet_Call) RunAndReturn(run func(context.Context, *ec2.CreateDefaultSubnetInput, ...func(*ec2.Options)) (*ec2.CreateDefaultSubnetOutput, error)) *EC2_CreateDefaultSubnet_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDefaultVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateDefaultVpc(ctx context.Context, params *ec2.CreateDefaultVpcInput, optFns ...func(*ec2.Options)) (*ec2.CreateDefaultVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateDefaultVpc")
	}

	var r0 *ec2.CreateDefaultVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDefaultVpcInput, ...func(*ec2.Options)) (*ec2.CreateDefaultVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDefaultVpcInput, ...func(*ec2.Options)) *ec2.CreateDefaultVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDefaultVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateDefaultVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateDefaultVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDefaultVpc'
type EC2_CreateDefaultVpc_Call struct {
	*mock.Call
}

// CreateDefaultVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateDefaultVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateDefaultVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateDefaultVpc_Call {
	return &EC2_CreateDefaultVpc_Call{Call: _e.mock.On("CreateDefaultVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateDefaultVpc_Call) Run(run func(ctx context.Context, params *ec2.CreateDefaultVpcInput, optFns ...func(*ec2.Options))) *EC2_CreateDefaultVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateDefaultVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateDefaultVpc_Call) Return(_a0 *ec2.CreateDefaultVpcOutput, _a1 error) *EC2_CreateDefaultVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateDefaultVpc_Call) RunAndReturn(run func(context.Context, *ec2.CreateDefaultVpcInput, ...func(*ec2.Options)) (*ec2.CreateDefaultVpcOutput, error)) *EC2_CreateDefaultVpc_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDelegateMacVolumeOwnershipTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateDelegateMacVolumeOwnershipTask(ctx context.Context, params *ec2.CreateDelegateMacVolumeOwnershipTaskInput, optFns ...func(*ec2.Options)) (*ec2.CreateDelegateMacVolumeOwnershipTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateDelegateMacVolumeOwnershipTask")
	}

	var r0 *ec2.CreateDelegateMacVolumeOwnershipTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDelegateMacVolumeOwnershipTaskInput, ...func(*ec2.Options)) (*ec2.CreateDelegateMacVolumeOwnershipTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDelegateMacVolumeOwnershipTaskInput, ...func(*ec2.Options)) *ec2.CreateDelegateMacVolumeOwnershipTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDelegateMacVolumeOwnershipTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateDelegateMacVolumeOwnershipTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateDelegateMacVolumeOwnershipTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDelegateMacVolumeOwnershipTask'
type EC2_CreateDelegateMacVolumeOwnershipTask_Call struct {
	*mock.Call
}

// CreateDelegateMacVolumeOwnershipTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateDelegateMacVolumeOwnershipTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateDelegateMacVolumeOwnershipTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateDelegateMacVolumeOwnershipTask_Call {
	return &EC2_CreateDelegateMacVolumeOwnershipTask_Call{Call: _e.mock.On("CreateDelegateMacVolumeOwnershipTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateDelegateMacVolumeOwnershipTask_Call) Run(run func(ctx context.Context, params *ec2.CreateDelegateMacVolumeOwnershipTaskInput, optFns ...func(*ec2.Options))) *EC2_CreateDelegateMacVolumeOwnershipTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateDelegateMacVolumeOwnershipTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateDelegateMacVolumeOwnershipTask_Call) Return(_a0 *ec2.CreateDelegateMacVolumeOwnershipTaskOutput, _a1 error) *EC2_CreateDelegateMacVolumeOwnershipTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateDelegateMacVolumeOwnershipTask_Call) RunAndReturn(run func(context.Context, *ec2.CreateDelegateMacVolumeOwnershipTaskInput, ...func(*ec2.Options)) (*ec2.CreateDelegateMacVolumeOwnershipTaskOutput, error)) *EC2_CreateDelegateMacVolumeOwnershipTask_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDhcpOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateDhcpOptions(ctx context.Context, params *ec2.CreateDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.CreateDhcpOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateDhcpOptions")
	}

	var r0 *ec2.CreateDhcpOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDhcpOptionsInput, ...func(*ec2.Options)) (*ec2.CreateDhcpOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateDhcpOptionsInput, ...func(*ec2.Options)) *ec2.CreateDhcpOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateDhcpOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateDhcpOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateDhcpOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDhcpOptions'
type EC2_CreateDhcpOptions_Call struct {
	*mock.Call
}

// CreateDhcpOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateDhcpOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateDhcpOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateDhcpOptions_Call {
	return &EC2_CreateDhcpOptions_Call{Call: _e.mock.On("CreateDhcpOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateDhcpOptions_Call) Run(run func(ctx context.Context, params *ec2.CreateDhcpOptionsInput, optFns ...func(*ec2.Options))) *EC2_CreateDhcpOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateDhcpOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateDhcpOptions_Call) Return(_a0 *ec2.CreateDhcpOptionsOutput, _a1 error) *EC2_CreateDhcpOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateDhcpOptions_Call) RunAndReturn(run func(context.Context, *ec2.CreateDhcpOptionsInput, ...func(*ec2.Options)) (*ec2.CreateDhcpOptionsOutput, error)) *EC2_CreateDhcpOptions_Call {
	_c.Call.Return(run)
	return _c
}

// CreateEgressOnlyInternetGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateEgressOnlyInternetGateway(ctx context.Context, params *ec2.CreateEgressOnlyInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateEgressOnlyInternetGateway")
	}

	var r0 *ec2.CreateEgressOnlyInternetGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateEgressOnlyInternetGatewayInput, ...func(*ec2.Options)) (*ec2.CreateEgressOnlyInternetGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateEgressOnlyInternetGatewayInput, ...func(*ec2.Options)) *ec2.CreateEgressOnlyInternetGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateEgressOnlyInternetGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateEgressOnlyInternetGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateEgressOnlyInternetGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEgressOnlyInternetGateway'
type EC2_CreateEgressOnlyInternetGateway_Call struct {
	*mock.Call
}

// CreateEgressOnlyInternetGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateEgressOnlyInternetGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateEgressOnlyInternetGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateEgressOnlyInternetGateway_Call {
	return &EC2_CreateEgressOnlyInternetGateway_Call{Call: _e.mock.On("CreateEgressOnlyInternetGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateEgressOnlyInternetGateway_Call) Run(run func(ctx context.Context, params *ec2.CreateEgressOnlyInternetGatewayInput, optFns ...func(*ec2.Options))) *EC2_CreateEgressOnlyInternetGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateEgressOnlyInternetGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateEgressOnlyInternetGateway_Call) Return(_a0 *ec2.CreateEgressOnlyInternetGatewayOutput, _a1 error) *EC2_CreateEgressOnlyInternetGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateEgressOnlyInternetGateway_Call) RunAndReturn(run func(context.Context, *ec2.CreateEgressOnlyInternetGatewayInput, ...func(*ec2.Options)) (*ec2.CreateEgressOnlyInternetGatewayOutput, error)) *EC2_CreateEgressOnlyInternetGateway_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFleet provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateFleet(ctx context.Context, params *ec2.CreateFleetInput, optFns ...func(*ec2.Options)) (*ec2.CreateFleetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateFleet")
	}

	var r0 *ec2.CreateFleetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFleetInput, ...func(*ec2.Options)) (*ec2.CreateFleetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFleetInput, ...func(*ec2.Options)) *ec2.CreateFleetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFleetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateFleetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateFleet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFleet'
type EC2_CreateFleet_Call struct {
	*mock.Call
}

// CreateFleet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateFleetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateFleet(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateFleet_Call {
	return &EC2_CreateFleet_Call{Call: _e.mock.On("CreateFleet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateFleet_Call) Run(run func(ctx context.Context, params *ec2.CreateFleetInput, optFns ...func(*ec2.Options))) *EC2_CreateFleet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateFleetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateFleet_Call) Return(_a0 *ec2.CreateFleetOutput, _a1 error) *EC2_CreateFleet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateFleet_Call) RunAndReturn(run func(context.Context, *ec2.CreateFleetInput, ...func(*ec2.Options)) (*ec2.CreateFleetOutput, error)) *EC2_CreateFleet_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFlowLogs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateFlowLogs(ctx context.Context, params *ec2.CreateFlowLogsInput, optFns ...func(*ec2.Options)) (*ec2.CreateFlowLogsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateFlowLogs")
	}

	var r0 *ec2.CreateFlowLogsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFlowLogsInput, ...func(*ec2.Options)) (*ec2.CreateFlowLogsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFlowLogsInput, ...func(*ec2.Options)) *ec2.CreateFlowLogsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFlowLogsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateFlowLogsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateFlowLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFlowLogs'
type EC2_CreateFlowLogs_Call struct {
	*mock.Call
}

// CreateFlowLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateFlowLogsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateFlowLogs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateFlowLogs_Call {
	return &EC2_CreateFlowLogs_Call{Call: _e.mock.On("CreateFlowLogs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateFlowLogs_Call) Run(run func(ctx context.Context, params *ec2.CreateFlowLogsInput, optFns ...func(*ec2.Options))) *EC2_CreateFlowLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateFlowLogsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateFlowLogs_Call) Return(_a0 *ec2.CreateFlowLogsOutput, _a1 error) *EC2_CreateFlowLogs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateFlowLogs_Call) RunAndReturn(run func(context.Context, *ec2.CreateFlowLogsInput, ...func(*ec2.Options)) (*ec2.CreateFlowLogsOutput, error)) *EC2_CreateFlowLogs_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFpgaImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateFpgaImage(ctx context.Context, params *ec2.CreateFpgaImageInput, optFns ...func(*ec2.Options)) (*ec2.CreateFpgaImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateFpgaImage")
	}

	var r0 *ec2.CreateFpgaImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFpgaImageInput, ...func(*ec2.Options)) (*ec2.CreateFpgaImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateFpgaImageInput, ...func(*ec2.Options)) *ec2.CreateFpgaImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateFpgaImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateFpgaImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateFpgaImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFpgaImage'
type EC2_CreateFpgaImage_Call struct {
	*mock.Call
}

// CreateFpgaImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateFpgaImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateFpgaImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateFpgaImage_Call {
	return &EC2_CreateFpgaImage_Call{Call: _e.mock.On("CreateFpgaImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateFpgaImage_Call) Run(run func(ctx context.Context, params *ec2.CreateFpgaImageInput, optFns ...func(*ec2.Options))) *EC2_CreateFpgaImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateFpgaImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateFpgaImage_Call) Return(_a0 *ec2.CreateFpgaImageOutput, _a1 error) *EC2_CreateFpgaImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateFpgaImage_Call) RunAndReturn(run func(context.Context, *ec2.CreateFpgaImageInput, ...func(*ec2.Options)) (*ec2.CreateFpgaImageOutput, error)) *EC2_CreateFpgaImage_Call {
	_c.Call.Return(run)
	return _c
}

// CreateImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateImage(ctx context.Context, params *ec2.CreateImageInput, optFns ...func(*ec2.Options)) (*ec2.CreateImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateImage")
	}

	var r0 *ec2.CreateImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateImageInput, ...func(*ec2.Options)) (*ec2.CreateImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateImageInput, ...func(*ec2.Options)) *ec2.CreateImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateImage'
type EC2_CreateImage_Call struct {
	*mock.Call
}

// CreateImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateImage_Call {
	return &EC2_CreateImage_Call{Call: _e.mock.On("CreateImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateImage_Call) Run(run func(ctx context.Context, params *ec2.CreateImageInput, optFns ...func(*ec2.Options))) *EC2_CreateImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateImage_Call) Return(_a0 *ec2.CreateImageOutput, _a1 error) *EC2_CreateImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateImage_Call) RunAndReturn(run func(context.Context, *ec2.CreateImageInput, ...func(*ec2.Options)) (*ec2.CreateImageOutput, error)) *EC2_CreateImage_Call {
	_c.Call.Return(run)
	return _c
}

// CreateImageUsageReport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateImageUsageReport(ctx context.Context, params *ec2.CreateImageUsageReportInput, optFns ...func(*ec2.Options)) (*ec2.CreateImageUsageReportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateImageUsageReport")
	}

	var r0 *ec2.CreateImageUsageReportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateImageUsageReportInput, ...func(*ec2.Options)) (*ec2.CreateImageUsageReportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateImageUsageReportInput, ...func(*ec2.Options)) *ec2.CreateImageUsageReportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateImageUsageReportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateImageUsageReportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateImageUsageReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateImageUsageReport'
type EC2_CreateImageUsageReport_Call struct {
	*mock.Call
}

// CreateImageUsageReport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateImageUsageReportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateImageUsageReport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateImageUsageReport_Call {
	return &EC2_CreateImageUsageReport_Call{Call: _e.mock.On("CreateImageUsageReport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateImageUsageReport_Call) Run(run func(ctx context.Context, params *ec2.CreateImageUsageReportInput, optFns ...func(*ec2.Options))) *EC2_CreateImageUsageReport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateImageUsageReportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateImageUsageReport_Call) Return(_a0 *ec2.CreateImageUsageReportOutput, _a1 error) *EC2_CreateImageUsageReport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateImageUsageReport_Call) RunAndReturn(run func(context.Context, *ec2.CreateImageUsageReportInput, ...func(*ec2.Options)) (*ec2.CreateImageUsageReportOutput, error)) *EC2_CreateImageUsageReport_Call {
	_c.Call.Return(run)
	return _c
}

// CreateInstanceConnectEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateInstanceConnectEndpoint(ctx context.Context, params *ec2.CreateInstanceConnectEndpointInput, optFns ...func(*ec2.Options)) (*ec2.CreateInstanceConnectEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateInstanceConnectEndpoint")
	}

	var r0 *ec2.CreateInstanceConnectEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInstanceConnectEndpointInput, ...func(*ec2.Options)) (*ec2.CreateInstanceConnectEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInstanceConnectEndpointInput, ...func(*ec2.Options)) *ec2.CreateInstanceConnectEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInstanceConnectEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateInstanceConnectEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateInstanceConnectEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstanceConnectEndpoint'
type EC2_CreateInstanceConnectEndpoint_Call struct {
	*mock.Call
}

// CreateInstanceConnectEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateInstanceConnectEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateInstanceConnectEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateInstanceConnectEndpoint_Call {
	return &EC2_CreateInstanceConnectEndpoint_Call{Call: _e.mock.On("CreateInstanceConnectEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateInstanceConnectEndpoint_Call) Run(run func(ctx context.Context, params *ec2.CreateInstanceConnectEndpointInput, optFns ...func(*ec2.Options))) *EC2_CreateInstanceConnectEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateInstanceConnectEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateInstanceConnectEndpoint_Call) Return(_a0 *ec2.CreateInstanceConnectEndpointOutput, _a1 error) *EC2_CreateInstanceConnectEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateInstanceConnectEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.CreateInstanceConnectEndpointInput, ...func(*ec2.Options)) (*ec2.CreateInstanceConnectEndpointOutput, error)) *EC2_CreateInstanceConnectEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// CreateInstanceEventWindow provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateInstanceEventWindow(ctx context.Context, params *ec2.CreateInstanceEventWindowInput, optFns ...func(*ec2.Options)) (*ec2.CreateInstanceEventWindowOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateInstanceEventWindow")
	}

	var r0 *ec2.CreateInstanceEventWindowOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.CreateInstanceEventWindowOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInstanceEventWindowInput, ...func(*ec2.Options)) *ec2.CreateInstanceEventWindowOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInstanceEventWindowOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateInstanceEventWindowInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateInstanceEventWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstanceEventWindow'
type EC2_CreateInstanceEventWindow_Call struct {
	*mock.Call
}

// CreateInstanceEventWindow is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateInstanceEventWindowInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateInstanceEventWindow(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateInstanceEventWindow_Call {
	return &EC2_CreateInstanceEventWindow_Call{Call: _e.mock.On("CreateInstanceEventWindow",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateInstanceEventWindow_Call) Run(run func(ctx context.Context, params *ec2.CreateInstanceEventWindowInput, optFns ...func(*ec2.Options))) *EC2_CreateInstanceEventWindow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateInstanceEventWindowInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateInstanceEventWindow_Call) Return(_a0 *ec2.CreateInstanceEventWindowOutput, _a1 error) *EC2_CreateInstanceEventWindow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateInstanceEventWindow_Call) RunAndReturn(run func(context.Context, *ec2.CreateInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.CreateInstanceEventWindowOutput, error)) *EC2_CreateInstanceEventWindow_Call {
	_c.Call.Return(run)
	return _c
}

// CreateInstanceExportTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateInstanceExportTask(ctx context.Context, params *ec2.CreateInstanceExportTaskInput, optFns ...func(*ec2.Options)) (*ec2.CreateInstanceExportTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateInstanceExportTask")
	}

	var r0 *ec2.CreateInstanceExportTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInstanceExportTaskInput, ...func(*ec2.Options)) (*ec2.CreateInstanceExportTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInstanceExportTaskInput, ...func(*ec2.Options)) *ec2.CreateInstanceExportTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInstanceExportTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateInstanceExportTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateInstanceExportTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstanceExportTask'
type EC2_CreateInstanceExportTask_Call struct {
	*mock.Call
}

// CreateInstanceExportTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateInstanceExportTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateInstanceExportTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateInstanceExportTask_Call {
	return &EC2_CreateInstanceExportTask_Call{Call: _e.mock.On("CreateInstanceExportTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateInstanceExportTask_Call) Run(run func(ctx context.Context, params *ec2.CreateInstanceExportTaskInput, optFns ...func(*ec2.Options))) *EC2_CreateInstanceExportTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateInstanceExportTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateInstanceExportTask_Call) Return(_a0 *ec2.CreateInstanceExportTaskOutput, _a1 error) *EC2_CreateInstanceExportTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateInstanceExportTask_Call) RunAndReturn(run func(context.Context, *ec2.CreateInstanceExportTaskInput, ...func(*ec2.Options)) (*ec2.CreateInstanceExportTaskOutput, error)) *EC2_CreateInstanceExportTask_Call {
	_c.Call.Return(run)
	return _c
}

// CreateInternetGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateInternetGateway(ctx context.Context, params *ec2.CreateInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateInternetGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateInternetGateway")
	}

	var r0 *ec2.CreateInternetGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInternetGatewayInput, ...func(*ec2.Options)) (*ec2.CreateInternetGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInternetGatewayInput, ...func(*ec2.Options)) *ec2.CreateInternetGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInternetGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateInternetGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateInternetGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInternetGateway'
type EC2_CreateInternetGateway_Call struct {
	*mock.Call
}

// CreateInternetGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateInternetGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateInternetGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateInternetGateway_Call {
	return &EC2_CreateInternetGateway_Call{Call: _e.mock.On("CreateInternetGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateInternetGateway_Call) Run(run func(ctx context.Context, params *ec2.CreateInternetGatewayInput, optFns ...func(*ec2.Options))) *EC2_CreateInternetGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateInternetGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateInternetGateway_Call) Return(_a0 *ec2.CreateInternetGatewayOutput, _a1 error) *EC2_CreateInternetGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateInternetGateway_Call) RunAndReturn(run func(context.Context, *ec2.CreateInternetGatewayInput, ...func(*ec2.Options)) (*ec2.CreateInternetGatewayOutput, error)) *EC2_CreateInternetGateway_Call {
	_c.Call.Return(run)
	return _c
}

// CreateInterruptibleCapacityReservationAllocation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateInterruptibleCapacityReservationAllocation(ctx context.Context, params *ec2.CreateInterruptibleCapacityReservationAllocationInput, optFns ...func(*ec2.Options)) (*ec2.CreateInterruptibleCapacityReservationAllocationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateInterruptibleCapacityReservationAllocation")
	}

	var r0 *ec2.CreateInterruptibleCapacityReservationAllocationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) (*ec2.CreateInterruptibleCapacityReservationAllocationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) *ec2.CreateInterruptibleCapacityReservationAllocationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateInterruptibleCapacityReservationAllocationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateInterruptibleCapacityReservationAllocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInterruptibleCapacityReservationAllocation'
type EC2_CreateInterruptibleCapacityReservationAllocation_Call struct {
	*mock.Call
}

// CreateInterruptibleCapacityReservationAllocation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateInterruptibleCapacityReservationAllocationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateInterruptibleCapacityReservationAllocation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateInterruptibleCapacityReservationAllocation_Call {
	return &EC2_CreateInterruptibleCapacityReservationAllocation_Call{Call: _e.mock.On("CreateInterruptibleCapacityReservationAllocation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateInterruptibleCapacityReservationAllocation_Call) Run(run func(ctx context.Context, params *ec2.CreateInterruptibleCapacityReservationAllocationInput, optFns ...func(*ec2.Options))) *EC2_CreateInterruptibleCapacityReservationAllocation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateInterruptibleCapacityReservationAllocationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateInterruptibleCapacityReservationAllocation_Call) Return(_a0 *ec2.CreateInterruptibleCapacityReservationAllocationOutput, _a1 error) *EC2_CreateInterruptibleCapacityReservationAllocation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateInterruptibleCapacityReservationAllocation_Call) RunAndReturn(run func(context.Context, *ec2.CreateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) (*ec2.CreateInterruptibleCapacityReservationAllocationOutput, error)) *EC2_CreateInterruptibleCapacityReservationAllocation_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIpam provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateIpam(ctx context.Context, params *ec2.CreateIpamInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateIpam")
	}

	var r0 *ec2.CreateIpamOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamInput, ...func(*ec2.Options)) (*ec2.CreateIpamOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamInput, ...func(*ec2.Options)) *ec2.CreateIpamOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateIpamOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateIpam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpam'
type EC2_CreateIpam_Call struct {
	*mock.Call
}

// CreateIpam is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateIpamInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateIpam(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpam_Call {
	return &EC2_CreateIpam_Call{Call: _e.mock.On("CreateIpam",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateIpam_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamInput, optFns ...func(*ec2.Options))) *EC2_CreateIpam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateIpamInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateIpam_Call) Return(_a0 *ec2.CreateIpamOutput, _a1 error) *EC2_CreateIpam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateIpam_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamInput, ...func(*ec2.Options)) (*ec2.CreateIpamOutput, error)) *EC2_CreateIpam_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIpamExternalResourceVerificationToken provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateIpamExternalResourceVerificationToken(ctx context.Context, params *ec2.CreateIpamExternalResourceVerificationTokenInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamExternalResourceVerificationTokenOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateIpamExternalResourceVerificationToken")
	}

	var r0 *ec2.CreateIpamExternalResourceVerificationTokenOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamExternalResourceVerificationTokenInput, ...func(*ec2.Options)) (*ec2.CreateIpamExternalResourceVerificationTokenOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamExternalResourceVerificationTokenInput, ...func(*ec2.Options)) *ec2.CreateIpamExternalResourceVerificationTokenOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateIpamExternalResourceVerificationTokenOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamExternalResourceVerificationTokenInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateIpamExternalResourceVerificationToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpamExternalResourceVerificationToken'
type EC2_CreateIpamExternalResourceVerificationToken_Call struct {
	*mock.Call
}

// CreateIpamExternalResourceVerificationToken is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateIpamExternalResourceVerificationTokenInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateIpamExternalResourceVerificationToken(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpamExternalResourceVerificationToken_Call {
	return &EC2_CreateIpamExternalResourceVerificationToken_Call{Call: _e.mock.On("CreateIpamExternalResourceVerificationToken",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateIpamExternalResourceVerificationToken_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamExternalResourceVerificationTokenInput, optFns ...func(*ec2.Options))) *EC2_CreateIpamExternalResourceVerificationToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateIpamExternalResourceVerificationTokenInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateIpamExternalResourceVerificationToken_Call) Return(_a0 *ec2.CreateIpamExternalResourceVerificationTokenOutput, _a1 error) *EC2_CreateIpamExternalResourceVerificationToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateIpamExternalResourceVerificationToken_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamExternalResourceVerificationTokenInput, ...func(*ec2.Options)) (*ec2.CreateIpamExternalResourceVerificationTokenOutput, error)) *EC2_CreateIpamExternalResourceVerificationToken_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIpamPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateIpamPolicy(ctx context.Context, params *ec2.CreateIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateIpamPolicy")
	}

	var r0 *ec2.CreateIpamPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPolicyInput, ...func(*ec2.Options)) (*ec2.CreateIpamPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPolicyInput, ...func(*ec2.Options)) *ec2.CreateIpamPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateIpamPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpamPolicy'
type EC2_CreateIpamPolicy_Call struct {
	*mock.Call
}

// CreateIpamPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateIpamPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpamPolicy_Call {
	return &EC2_CreateIpamPolicy_Call{Call: _e.mock.On("CreateIpamPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_CreateIpamPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateIpamPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateIpamPolicy_Call) Return(_a0 *ec2.CreateIpamPolicyOutput, _a1 error) *EC2_CreateIpamPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamPolicyInput, ...func(*ec2.Options)) (*ec2.CreateIpamPolicyOutput, error)) *EC2_CreateIpamPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIpamPool provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateIpamPool(ctx context.Context, params *ec2.CreateIpamPoolInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamPoolOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateIpamPool")
	}

	var r0 *ec2.CreateIpamPoolOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPoolInput, ...func(*ec2.Options)) (*ec2.CreateIpamPoolOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPoolInput, ...func(*ec2.Options)) *ec2.CreateIpamPoolOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateIpamPoolOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamPoolInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateIpamPool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpamPool'
type EC2_CreateIpamPool_Call struct {
	*mock.Call
}

// CreateIpamPool is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateIpamPoolInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateIpamPool(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpamPool_Call {
	return &EC2_CreateIpamPool_Call{Call: _e.mock.On("CreateIpamPool",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateIpamPool_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamPoolInput, optFns ...func(*ec2.Options))) *EC2_CreateIpamPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateIpamPoolInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateIpamPool_Call) Return(_a0 *ec2.CreateIpamPoolOutput, _a1 error) *EC2_CreateIpamPool_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateIpamPool_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamPoolInput, ...func(*ec2.Options)) (*ec2.CreateIpamPoolOutput, error)) *EC2_CreateIpamPool_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIpamPrefixListResolver provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateIpamPrefixListResolver(ctx context.Context, params *ec2.CreateIpamPrefixListResolverInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamPrefixListResolverOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateIpamPrefixListResolver")
	}

	var r0 *ec2.CreateIpamPrefixListResolverOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPrefixListResolverInput, ...func(*ec2.Options)) (*ec2.CreateIpamPrefixListResolverOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPrefixListResolverInput, ...func(*ec2.Options)) *ec2.CreateIpamPrefixListResolverOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateIpamPrefixListResolverOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamPrefixListResolverInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateIpamPrefixListResolver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpamPrefixListResolver'
type EC2_CreateIpamPrefixListResolver_Call struct {
	*mock.Call
}

// CreateIpamPrefixListResolver is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateIpamPrefixListResolverInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateIpamPrefixListResolver(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpamPrefixListResolver_Call {
	return &EC2_CreateIpamPrefixListResolver_Call{Call: _e.mock.On("CreateIpamPrefixListResolver",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateIpamPrefixListResolver_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamPrefixListResolverInput, optFns ...func(*ec2.Options))) *EC2_CreateIpamPrefixListResolver_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateIpamPrefixListResolverInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateIpamPrefixListResolver_Call) Return(_a0 *ec2.CreateIpamPrefixListResolverOutput, _a1 error) *EC2_CreateIpamPrefixListResolver_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateIpamPrefixListResolver_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamPrefixListResolverInput, ...func(*ec2.Options)) (*ec2.CreateIpamPrefixListResolverOutput, error)) *EC2_CreateIpamPrefixListResolver_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIpamPrefixListResolverTarget provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateIpamPrefixListResolverTarget(ctx context.Context, params *ec2.CreateIpamPrefixListResolverTargetInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamPrefixListResolverTargetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateIpamPrefixListResolverTarget")
	}

	var r0 *ec2.CreateIpamPrefixListResolverTargetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) (*ec2.CreateIpamPrefixListResolverTargetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) *ec2.CreateIpamPrefixListResolverTargetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateIpamPrefixListResolverTargetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateIpamPrefixListResolverTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpamPrefixListResolverTarget'
type EC2_CreateIpamPrefixListResolverTarget_Call struct {
	*mock.Call
}

// CreateIpamPrefixListResolverTarget is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateIpamPrefixListResolverTargetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateIpamPrefixListResolverTarget(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpamPrefixListResolverTarget_Call {
	return &EC2_CreateIpamPrefixListResolverTarget_Call{Call: _e.mock.On("CreateIpamPrefixListResolverTarget",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateIpamPrefixListResolverTarget_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamPrefixListResolverTargetInput, optFns ...func(*ec2.Options))) *EC2_CreateIpamPrefixListResolverTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateIpamPrefixListResolverTargetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateIpamPrefixListResolverTarget_Call) Return(_a0 *ec2.CreateIpamPrefixListResolverTargetOutput, _a1 error) *EC2_CreateIpamPrefixListResolverTarget_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateIpamPrefixListResolverTarget_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) (*ec2.CreateIpamPrefixListResolverTargetOutput, error)) *EC2_CreateIpamPrefixListResolverTarget_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIpamResourceDiscovery provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateIpamResourceDiscovery(ctx context.Context, params *ec2.CreateIpamResourceDiscoveryInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamResourceDiscoveryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateIpamResourceDiscovery")
	}

	var r0 *ec2.CreateIpamResourceDiscoveryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.CreateIpamResourceDiscoveryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamResourceDiscoveryInput, ...func(*ec2.Options)) *ec2.CreateIpamResourceDiscoveryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateIpamResourceDiscoveryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamResourceDiscoveryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateIpamResourceDiscovery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpamResourceDiscovery'
type EC2_CreateIpamResourceDiscovery_Call struct {
	*mock.Call
}

// CreateIpamResourceDiscovery is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateIpamResourceDiscoveryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateIpamResourceDiscovery(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpamResourceDiscovery_Call {
	return &EC2_CreateIpamResourceDiscovery_Call{Call: _e.mock.On("CreateIpamResourceDiscovery",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateIpamResourceDiscovery_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamResourceDiscoveryInput, optFns ...func(*ec2.Options))) *EC2_CreateIpamResourceDiscovery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateIpamResourceDiscoveryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateIpamResourceDiscovery_Call) Return(_a0 *ec2.CreateIpamResourceDiscoveryOutput, _a1 error) *EC2_CreateIpamResourceDiscovery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateIpamResourceDiscovery_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.CreateIpamResourceDiscoveryOutput, error)) *EC2_CreateIpamResourceDiscovery_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIpamScope provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateIpamScope(ctx context.Context, params *ec2.CreateIpamScopeInput, optFns ...func(*ec2.Options)) (*ec2.CreateIpamScopeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateIpamScope")
	}

	var r0 *ec2.CreateIpamScopeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamScopeInput, ...func(*ec2.Options)) (*ec2.CreateIpamScopeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateIpamScopeInput, ...func(*ec2.Options)) *ec2.CreateIpamScopeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateIpamScopeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateIpamScopeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateIpamScope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIpamScope'
type EC2_CreateIpamScope_Call struct {
	*mock.Call
}

// CreateIpamScope is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateIpamScopeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateIpamScope(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateIpamScope_Call {
	return &EC2_CreateIpamScope_Call{Call: _e.mock.On("CreateIpamScope",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateIpamScope_Call) Run(run func(ctx context.Context, params *ec2.CreateIpamScopeInput, optFns ...func(*ec2.Options))) *EC2_CreateIpamScope_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateIpamScopeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateIpamScope_Call) Return(_a0 *ec2.CreateIpamScopeOutput, _a1 error) *EC2_CreateIpamScope_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateIpamScope_Call) RunAndReturn(run func(context.Context, *ec2.CreateIpamScopeInput, ...func(*ec2.Options)) (*ec2.CreateIpamScopeOutput, error)) *EC2_CreateIpamScope_Call {
	_c.Call.Return(run)
	return _c
}

// CreateKeyPair provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateKeyPair(ctx context.Context, params *ec2.CreateKeyPairInput, optFns ...func(*ec2.Options)) (*ec2.CreateKeyPairOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateKeyPair")
	}

	var r0 *ec2.CreateKeyPairOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateKeyPairInput, ...func(*ec2.Options)) (*ec2.CreateKeyPairOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateKeyPairInput, ...func(*ec2.Options)) *ec2.CreateKeyPairOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateKeyPairOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateKeyPairInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateKeyPair_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateKeyPair'
type EC2_CreateKeyPair_Call struct {
	*mock.Call
}

// CreateKeyPair is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateKeyPairInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateKeyPair(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateKeyPair_Call {
	return &EC2_CreateKeyPair_Call{Call: _e.mock.On("CreateKeyPair",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateKeyPair_Call) Run(run func(ctx context.Context, params *ec2.CreateKeyPairInput, optFns ...func(*ec2.Options))) *EC2_CreateKeyPair_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateKeyPairInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateKeyPair_Call) Return(_a0 *ec2.CreateKeyPairOutput, _a1 error) *EC2_CreateKeyPair_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateKeyPair_Call) RunAndReturn(run func(context.Context, *ec2.CreateKeyPairInput, ...func(*ec2.Options)) (*ec2.CreateKeyPairOutput, error)) *EC2_CreateKeyPair_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLaunchTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateLaunchTemplate(ctx context.Context, params *ec2.CreateLaunchTemplateInput, optFns ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateLaunchTemplate")
	}

	var r0 *ec2.CreateLaunchTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLaunchTemplateInput, ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLaunchTemplateInput, ...func(*ec2.Options)) *ec2.CreateLaunchTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLaunchTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateLaunchTemplateInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateLaunchTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLaunchTemplate'
type EC2_CreateLaunchTemplate_Call struct {
	*mock.Call
}

// CreateLaunchTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateLaunchTemplateInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateLaunchTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateLaunchTemplate_Call {
	return &EC2_CreateLaunchTemplate_Call{Call: _e.mock.On("CreateLaunchTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateLaunchTemplate_Call) Run(run func(ctx context.Context, params *ec2.CreateLaunchTemplateInput, optFns ...func(*ec2.Options))) *EC2_CreateLaunchTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateLaunchTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateLaunchTemplate_Call) Return(_a0 *ec2.CreateLaunchTemplateOutput, _a1 error) *EC2_CreateLaunchTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateLaunchTemplate_Call) RunAndReturn(run func(context.Context, *ec2.CreateLaunchTemplateInput, ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateOutput, error)) *EC2_CreateLaunchTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLaunchTemplateVersion provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateLaunchTemplateVersion(ctx context.Context, params *ec2.CreateLaunchTemplateVersionInput, optFns ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateVersionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateLaunchTemplateVersion")
	}

	var r0 *ec2.CreateLaunchTemplateVersionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLaunchTemplateVersionInput, ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateVersionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLaunchTemplateVersionInput, ...func(*ec2.Options)) *ec2.CreateLaunchTemplateVersionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLaunchTemplateVersionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateLaunchTemplateVersionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateLaunchTemplateVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLaunchTemplateVersion'
type EC2_CreateLaunchTemplateVersion_Call struct {
	*mock.Call
}

// CreateLaunchTemplateVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateLaunchTemplateVersionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateLaunchTemplateVersion(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateLaunchTemplateVersion_Call {
	return &EC2_CreateLaunchTemplateVersion_Call{Call: _e.mock.On("CreateLaunchTemplateVersion",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateLaunchTemplateVersion_Call) Run(run func(ctx context.Context, params *ec2.CreateLaunchTemplateVersionInput, optFns ...func(*ec2.Options))) *EC2_CreateLaunchTemplateVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateLaunchTemplateVersionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateLaunchTemplateVersion_Call) Return(_a0 *ec2.CreateLaunchTemplateVersionOutput, _a1 error) *EC2_CreateLaunchTemplateVersion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateLaunchTemplateVersion_Call) RunAndReturn(run func(context.Context, *ec2.CreateLaunchTemplateVersionInput, ...func(*ec2.Options)) (*ec2.CreateLaunchTemplateVersionOutput, error)) *EC2_CreateLaunchTemplateVersion_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLocalGatewayRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateLocalGatewayRoute(ctx context.Context, params *ec2.CreateLocalGatewayRouteInput, optFns ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateLocalGatewayRoute")
	}

	var r0 *ec2.CreateLocalGatewayRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteInput, ...func(*ec2.Options)) *ec2.CreateLocalGatewayRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateLocalGatewayRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateLocalGatewayRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLocalGatewayRoute'
type EC2_CreateLocalGatewayRoute_Call struct {
	*mock.Call
}

// CreateLocalGatewayRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateLocalGatewayRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateLocalGatewayRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateLocalGatewayRoute_Call {
	return &EC2_CreateLocalGatewayRoute_Call{Call: _e.mock.On("CreateLocalGatewayRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateLocalGatewayRoute_Call) Run(run func(ctx context.Context, params *ec2.CreateLocalGatewayRouteInput, optFns ...func(*ec2.Options))) *EC2_CreateLocalGatewayRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateLocalGatewayRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateLocalGatewayRoute_Call) Return(_a0 *ec2.CreateLocalGatewayRouteOutput, _a1 error) *EC2_CreateLocalGatewayRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateLocalGatewayRoute_Call) RunAndReturn(run func(context.Context, *ec2.CreateLocalGatewayRouteInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteOutput, error)) *EC2_CreateLocalGatewayRoute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLocalGatewayRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateLocalGatewayRouteTable(ctx context.Context, params *ec2.CreateLocalGatewayRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateLocalGatewayRouteTable")
	}

	var r0 *ec2.CreateLocalGatewayRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteTableInput, ...func(*ec2.Options)) *ec2.CreateLocalGatewayRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateLocalGatewayRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateLocalGatewayRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLocalGatewayRouteTable'
type EC2_CreateLocalGatewayRouteTable_Call struct {
	*mock.Call
}

// CreateLocalGatewayRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateLocalGatewayRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateLocalGatewayRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateLocalGatewayRouteTable_Call {
	return &EC2_CreateLocalGatewayRouteTable_Call{Call: _e.mock.On("CreateLocalGatewayRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateLocalGatewayRouteTable_Call) Run(run func(ctx context.Context, params *ec2.CreateLocalGatewayRouteTableInput, optFns ...func(*ec2.Options))) *EC2_CreateLocalGatewayRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateLocalGatewayRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateLocalGatewayRouteTable_Call) Return(_a0 *ec2.CreateLocalGatewayRouteTableOutput, _a1 error) *EC2_CreateLocalGatewayRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateLocalGatewayRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.CreateLocalGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableOutput, error)) *EC2_CreateLocalGatewayRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(ctx context.Context, params *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, optFns ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation")
	}

	var r0 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, ...func(*ec2.Options)) *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation'
type EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call struct {
	*mock.Call
}

// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call {
	return &EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call{Call: _e.mock.On("CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call) Run(run func(ctx context.Context, params *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, optFns ...func(*ec2.Options))) *EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call) Return(_a0 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, _a1 error) *EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call) RunAndReturn(run func(context.Context, *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error)) *EC2_CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLocalGatewayRouteTableVpcAssociation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateLocalGatewayRouteTableVpcAssociation(ctx context.Context, params *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, optFns ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateLocalGatewayRouteTableVpcAssociation")
	}

	var r0 *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, ...func(*ec2.Options)) *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateLocalGatewayRouteTableVpcAssociation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLocalGatewayRouteTableVpcAssociation'
type EC2_CreateLocalGatewayRouteTableVpcAssociation_Call struct {
	*mock.Call
}

// CreateLocalGatewayRouteTableVpcAssociation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateLocalGatewayRouteTableVpcAssociationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateLocalGatewayRouteTableVpcAssociation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateLocalGatewayRouteTableVpcAssociation_Call {
	return &EC2_CreateLocalGatewayRouteTableVpcAssociation_Call{Call: _e.mock.On("CreateLocalGatewayRouteTableVpcAssociation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateLocalGatewayRouteTableVpcAssociation_Call) Run(run func(ctx context.Context, params *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, optFns ...func(*ec2.Options))) *EC2_CreateLocalGatewayRouteTableVpcAssociation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateLocalGatewayRouteTableVpcAssociationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateLocalGatewayRouteTableVpcAssociation_Call) Return(_a0 *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, _a1 error) *EC2_CreateLocalGatewayRouteTableVpcAssociation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateLocalGatewayRouteTableVpcAssociation_Call) RunAndReturn(run func(context.Context, *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error)) *EC2_CreateLocalGatewayRouteTableVpcAssociation_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLocalGatewayVirtualInterface provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateLocalGatewayVirtualInterface(ctx context.Context, params *ec2.CreateLocalGatewayVirtualInterfaceInput, optFns ...func(*ec2.Options)) (*ec2.CreateLocalGatewayVirtualInterfaceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateLocalGatewayVirtualInterface")
	}

	var r0 *ec2.CreateLocalGatewayVirtualInterfaceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayVirtualInterfaceInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayVirtualInterfaceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayVirtualInterfaceInput, ...func(*ec2.Options)) *ec2.CreateLocalGatewayVirtualInterfaceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayVirtualInterfaceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateLocalGatewayVirtualInterfaceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateLocalGatewayVirtualInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLocalGatewayVirtualInterface'
type EC2_CreateLocalGatewayVirtualInterface_Call struct {
	*mock.Call
}

// CreateLocalGatewayVirtualInterface is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateLocalGatewayVirtualInterfaceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateLocalGatewayVirtualInterface(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateLocalGatewayVirtualInterface_Call {
	return &EC2_CreateLocalGatewayVirtualInterface_Call{Call: _e.mock.On("CreateLocalGatewayVirtualInterface",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateLocalGatewayVirtualInterface_Call) Run(run func(ctx context.Context, params *ec2.CreateLocalGatewayVirtualInterfaceInput, optFns ...func(*ec2.Options))) *EC2_CreateLocalGatewayVirtualInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateLocalGatewayVirtualInterfaceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateLocalGatewayVirtualInterface_Call) Return(_a0 *ec2.CreateLocalGatewayVirtualInterfaceOutput, _a1 error) *EC2_CreateLocalGatewayVirtualInterface_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateLocalGatewayVirtualInterface_Call) RunAndReturn(run func(context.Context, *ec2.CreateLocalGatewayVirtualInterfaceInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayVirtualInterfaceOutput, error)) *EC2_CreateLocalGatewayVirtualInterface_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLocalGatewayVirtualInterfaceGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateLocalGatewayVirtualInterfaceGroup(ctx context.Context, params *ec2.CreateLocalGatewayVirtualInterfaceGroupInput, optFns ...func(*ec2.Options)) (*ec2.CreateLocalGatewayVirtualInterfaceGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateLocalGatewayVirtualInterfaceGroup")
	}

	var r0 *ec2.CreateLocalGatewayVirtualInterfaceGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayVirtualInterfaceGroupInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayVirtualInterfaceGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateLocalGatewayVirtualInterfaceGroupInput, ...func(*ec2.Options)) *ec2.CreateLocalGatewayVirtualInterfaceGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateLocalGatewayVirtualInterfaceGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateLocalGatewayVirtualInterfaceGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateLocalGatewayVirtualInterfaceGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLocalGatewayVirtualInterfaceGroup'
type EC2_CreateLocalGatewayVirtualInterfaceGroup_Call struct {
	*mock.Call
}

// CreateLocalGatewayVirtualInterfaceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateLocalGatewayVirtualInterfaceGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateLocalGatewayVirtualInterfaceGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateLocalGatewayVirtualInterfaceGroup_Call {
	return &EC2_CreateLocalGatewayVirtualInterfaceGroup_Call{Call: _e.mock.On("CreateLocalGatewayVirtualInterfaceGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateLocalGatewayVirtualInterfaceGroup_Call) Run(run func(ctx context.Context, params *ec2.CreateLocalGatewayVirtualInterfaceGroupInput, optFns ...func(*ec2.Options))) *EC2_CreateLocalGatewayVirtualInterfaceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateLocalGatewayVirtualInterfaceGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateLocalGatewayVirtualInterfaceGroup_Call) Return(_a0 *ec2.CreateLocalGatewayVirtualInterfaceGroupOutput, _a1 error) *EC2_CreateLocalGatewayVirtualInterfaceGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateLocalGatewayVirtualInterfaceGroup_Call) RunAndReturn(run func(context.Context, *ec2.CreateLocalGatewayVirtualInterfaceGroupInput, ...func(*ec2.Options)) (*ec2.CreateLocalGatewayVirtualInterfaceGroupOutput, error)) *EC2_CreateLocalGatewayVirtualInterfaceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateMacSystemIntegrityProtectionModificationTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateMacSystemIntegrityProtectionModificationTask(ctx context.Context, params *ec2.CreateMacSystemIntegrityProtectionModificationTaskInput, optFns ...func(*ec2.Options)) (*ec2.CreateMacSystemIntegrityProtectionModificationTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateMacSystemIntegrityProtectionModificationTask")
	}

	var r0 *ec2.CreateMacSystemIntegrityProtectionModificationTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateMacSystemIntegrityProtectionModificationTaskInput, ...func(*ec2.Options)) (*ec2.CreateMacSystemIntegrityProtectionModificationTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateMacSystemIntegrityProtectionModificationTaskInput, ...func(*ec2.Options)) *ec2.CreateMacSystemIntegrityProtectionModificationTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateMacSystemIntegrityProtectionModificationTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateMacSystemIntegrityProtectionModificationTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateMacSystemIntegrityProtectionModificationTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMacSystemIntegrityProtectionModificationTask'
type EC2_CreateMacSystemIntegrityProtectionModificationTask_Call struct {
	*mock.Call
}

// CreateMacSystemIntegrityProtectionModificationTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateMacSystemIntegrityProtectionModificationTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateMacSystemIntegrityProtectionModificationTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateMacSystemIntegrityProtectionModificationTask_Call {
	return &EC2_CreateMacSystemIntegrityProtectionModificationTask_Call{Call: _e.mock.On("CreateMacSystemIntegrityProtectionModificationTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateMacSystemIntegrityProtectionModificationTask_Call) Run(run func(ctx context.Context, params *ec2.CreateMacSystemIntegrityProtectionModificationTaskInput, optFns ...func(*ec2.Options))) *EC2_CreateMacSystemIntegrityProtectionModificationTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateMacSystemIntegrityProtectionModificationTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateMacSystemIntegrityProtectionModificationTask_Call) Return(_a0 *ec2.CreateMacSystemIntegrityProtectionModificationTaskOutput, _a1 error) *EC2_CreateMacSystemIntegrityProtectionModificationTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateMacSystemIntegrityProtectionModificationTask_Call) RunAndReturn(run func(context.Context, *ec2.CreateMacSystemIntegrityProtectionModificationTaskInput, ...func(*ec2.Options)) (*ec2.CreateMacSystemIntegrityProtectionModificationTaskOutput, error)) *EC2_CreateMacSystemIntegrityProtectionModificationTask_Call {
	_c.Call.Return(run)
	return _c
}

// CreateManagedPrefixList provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateManagedPrefixList(ctx context.Context, params *ec2.CreateManagedPrefixListInput, optFns ...func(*ec2.Options)) (*ec2.CreateManagedPrefixListOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateManagedPrefixList")
	}

	var r0 *ec2.CreateManagedPrefixListOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateManagedPrefixListInput, ...func(*ec2.Options)) (*ec2.CreateManagedPrefixListOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateManagedPrefixListInput, ...func(*ec2.Options)) *ec2.CreateManagedPrefixListOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateManagedPrefixListOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateManagedPrefixListInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateManagedPrefixList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateManagedPrefixList'
type EC2_CreateManagedPrefixList_Call struct {
	*mock.Call
}

// CreateManagedPrefixList is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateManagedPrefixListInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateManagedPrefixList(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateManagedPrefixList_Call {
	return &EC2_CreateManagedPrefixList_Call{Call: _e.mock.On("CreateManagedPrefixList",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateManagedPrefixList_Call) Run(run func(ctx context.Context, params *ec2.CreateManagedPrefixListInput, optFns ...func(*ec2.Options))) *EC2_CreateManagedPrefixList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateManagedPrefixListInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateManagedPrefixList_Call) Return(_a0 *ec2.CreateManagedPrefixListOutput, _a1 error) *EC2_CreateManagedPrefixList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateManagedPrefixList_Call) RunAndReturn(run func(context.Context, *ec2.CreateManagedPrefixListInput, ...func(*ec2.Options)) (*ec2.CreateManagedPrefixListOutput, error)) *EC2_CreateManagedPrefixList_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNatGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateNatGateway(ctx context.Context, params *ec2.CreateNatGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateNatGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateNatGateway")
	}

	var r0 *ec2.CreateNatGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNatGatewayInput, ...func(*ec2.Options)) (*ec2.CreateNatGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNatGatewayInput, ...func(*ec2.Options)) *ec2.CreateNatGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNatGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateNatGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateNatGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNatGateway'
type EC2_CreateNatGateway_Call struct {
	*mock.Call
}

// CreateNatGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateNatGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateNatGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateNatGateway_Call {
	return &EC2_CreateNatGateway_Call{Call: _e.mock.On("CreateNatGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateNatGateway_Call) Run(run func(ctx context.Context, params *ec2.CreateNatGatewayInput, optFns ...func(*ec2.Options))) *EC2_CreateNatGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateNatGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateNatGateway_Call) Return(_a0 *ec2.CreateNatGatewayOutput, _a1 error) *EC2_CreateNatGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateNatGateway_Call) RunAndReturn(run func(context.Context, *ec2.CreateNatGatewayInput, ...func(*ec2.Options)) (*ec2.CreateNatGatewayOutput, error)) *EC2_CreateNatGateway_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNetworkAcl provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateNetworkAcl(ctx context.Context, params *ec2.CreateNetworkAclInput, optFns ...func(*ec2.Options)) (*ec2.CreateNetworkAclOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateNetworkAcl")
	}

	var r0 *ec2.CreateNetworkAclOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkAclInput, ...func(*ec2.Options)) (*ec2.CreateNetworkAclOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkAclInput, ...func(*ec2.Options)) *ec2.CreateNetworkAclOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkAclOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateNetworkAclInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateNetworkAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNetworkAcl'
type EC2_CreateNetworkAcl_Call struct {
	*mock.Call
}

// CreateNetworkAcl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateNetworkAclInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateNetworkAcl(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateNetworkAcl_Call {
	return &EC2_CreateNetworkAcl_Call{Call: _e.mock.On("CreateNetworkAcl",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateNetworkAcl_Call) Run(run func(ctx context.Context, params *ec2.CreateNetworkAclInput, optFns ...func(*ec2.Options))) *EC2_CreateNetworkAcl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateNetworkAclInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateNetworkAcl_Call) Return(_a0 *ec2.CreateNetworkAclOutput, _a1 error) *EC2_CreateNetworkAcl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateNetworkAcl_Call) RunAndReturn(run func(context.Context, *ec2.CreateNetworkAclInput, ...func(*ec2.Options)) (*ec2.CreateNetworkAclOutput, error)) *EC2_CreateNetworkAcl_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNetworkAclEntry provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateNetworkAclEntry(ctx context.Context, params *ec2.CreateNetworkAclEntryInput, optFns ...func(*ec2.Options)) (*ec2.CreateNetworkAclEntryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateNetworkAclEntry")
	}

	var r0 *ec2.CreateNetworkAclEntryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkAclEntryInput, ...func(*ec2.Options)) (*ec2.CreateNetworkAclEntryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkAclEntryInput, ...func(*ec2.Options)) *ec2.CreateNetworkAclEntryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkAclEntryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateNetworkAclEntryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateNetworkAclEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNetworkAclEntry'
type EC2_CreateNetworkAclEntry_Call struct {
	*mock.Call
}

// CreateNetworkAclEntry is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateNetworkAclEntryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateNetworkAclEntry(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateNetworkAclEntry_Call {
	return &EC2_CreateNetworkAclEntry_Call{Call: _e.mock.On("CreateNetworkAclEntry",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateNetworkAclEntry_Call) Run(run func(ctx context.Context, params *ec2.CreateNetworkAclEntryInput, optFns ...func(*ec2.Options))) *EC2_CreateNetworkAclEntry_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateNetworkAclEntryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateNetworkAclEntry_Call) Return(_a0 *ec2.CreateNetworkAclEntryOutput, _a1 error) *EC2_CreateNetworkAclEntry_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateNetworkAclEntry_Call) RunAndReturn(run func(context.Context, *ec2.CreateNetworkAclEntryInput, ...func(*ec2.Options)) (*ec2.CreateNetworkAclEntryOutput, error)) *EC2_CreateNetworkAclEntry_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNetworkInsightsAccessScope provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateNetworkInsightsAccessScope(ctx context.Context, params *ec2.CreateNetworkInsightsAccessScopeInput, optFns ...func(*ec2.Options)) (*ec2.CreateNetworkInsightsAccessScopeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateNetworkInsightsAccessScope")
	}

	var r0 *ec2.CreateNetworkInsightsAccessScopeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInsightsAccessScopeInput, ...func(*ec2.Options)) (*ec2.CreateNetworkInsightsAccessScopeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInsightsAccessScopeInput, ...func(*ec2.Options)) *ec2.CreateNetworkInsightsAccessScopeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInsightsAccessScopeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateNetworkInsightsAccessScopeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateNetworkInsightsAccessScope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNetworkInsightsAccessScope'
type EC2_CreateNetworkInsightsAccessScope_Call struct {
	*mock.Call
}

// CreateNetworkInsightsAccessScope is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateNetworkInsightsAccessScopeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateNetworkInsightsAccessScope(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateNetworkInsightsAccessScope_Call {
	return &EC2_CreateNetworkInsightsAccessScope_Call{Call: _e.mock.On("CreateNetworkInsightsAccessScope",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateNetworkInsightsAccessScope_Call) Run(run func(ctx context.Context, params *ec2.CreateNetworkInsightsAccessScopeInput, optFns ...func(*ec2.Options))) *EC2_CreateNetworkInsightsAccessScope_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateNetworkInsightsAccessScopeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateNetworkInsightsAccessScope_Call) Return(_a0 *ec2.CreateNetworkInsightsAccessScopeOutput, _a1 error) *EC2_CreateNetworkInsightsAccessScope_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateNetworkInsightsAccessScope_Call) RunAndReturn(run func(context.Context, *ec2.CreateNetworkInsightsAccessScopeInput, ...func(*ec2.Options)) (*ec2.CreateNetworkInsightsAccessScopeOutput, error)) *EC2_CreateNetworkInsightsAccessScope_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNetworkInsightsPath provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateNetworkInsightsPath(ctx context.Context, params *ec2.CreateNetworkInsightsPathInput, optFns ...func(*ec2.Options)) (*ec2.CreateNetworkInsightsPathOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateNetworkInsightsPath")
	}

	var r0 *ec2.CreateNetworkInsightsPathOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInsightsPathInput, ...func(*ec2.Options)) (*ec2.CreateNetworkInsightsPathOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInsightsPathInput, ...func(*ec2.Options)) *ec2.CreateNetworkInsightsPathOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInsightsPathOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateNetworkInsightsPathInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateNetworkInsightsPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNetworkInsightsPath'
type EC2_CreateNetworkInsightsPath_Call struct {
	*mock.Call
}

// CreateNetworkInsightsPath is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateNetworkInsightsPathInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateNetworkInsightsPath(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateNetworkInsightsPath_Call {
	return &EC2_CreateNetworkInsightsPath_Call{Call: _e.mock.On("CreateNetworkInsightsPath",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateNetworkInsightsPath_Call) Run(run func(ctx context.Context, params *ec2.CreateNetworkInsightsPathInput, optFns ...func(*ec2.Options))) *EC2_CreateNetworkInsightsPath_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateNetworkInsightsPathInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateNetworkInsightsPath_Call) Return(_a0 *ec2.CreateNetworkInsightsPathOutput, _a1 error) *EC2_CreateNetworkInsightsPath_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateNetworkInsightsPath_Call) RunAndReturn(run func(context.Context, *ec2.CreateNetworkInsightsPathInput, ...func(*ec2.Options)) (*ec2.CreateNetworkInsightsPathOutput, error)) *EC2_CreateNetworkInsightsPath_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNetworkInterface provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateNetworkInterface(ctx context.Context, params *ec2.CreateNetworkInterfaceInput, optFns ...func(*ec2.Options)) (*ec2.CreateNetworkInterfaceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateNetworkInterface")
	}

	var r0 *ec2.CreateNetworkInterfaceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInterfaceInput, ...func(*ec2.Options)) (*ec2.CreateNetworkInterfaceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInterfaceInput, ...func(*ec2.Options)) *ec2.CreateNetworkInterfaceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInterfaceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateNetworkInterfaceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateNetworkInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNetworkInterface'
type EC2_CreateNetworkInterface_Call struct {
	*mock.Call
}

// CreateNetworkInterface is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateNetworkInterfaceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateNetworkInterface(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateNetworkInterface_Call {
	return &EC2_CreateNetworkInterface_Call{Call: _e.mock.On("CreateNetworkInterface",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateNetworkInterface_Call) Run(run func(ctx context.Context, params *ec2.CreateNetworkInterfaceInput, optFns ...func(*ec2.Options))) *EC2_CreateNetworkInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateNetworkInterfaceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateNetworkInterface_Call) Return(_a0 *ec2.CreateNetworkInterfaceOutput, _a1 error) *EC2_CreateNetworkInterface_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateNetworkInterface_Call) RunAndReturn(run func(context.Context, *ec2.CreateNetworkInterfaceInput, ...func(*ec2.Options)) (*ec2.CreateNetworkInterfaceOutput, error)) *EC2_CreateNetworkInterface_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNetworkInterfacePermission provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateNetworkInterfacePermission(ctx context.Context, params *ec2.CreateNetworkInterfacePermissionInput, optFns ...func(*ec2.Options)) (*ec2.CreateNetworkInterfacePermissionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateNetworkInterfacePermission")
	}

	var r0 *ec2.CreateNetworkInterfacePermissionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInterfacePermissionInput, ...func(*ec2.Options)) (*ec2.CreateNetworkInterfacePermissionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateNetworkInterfacePermissionInput, ...func(*ec2.Options)) *ec2.CreateNetworkInterfacePermissionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateNetworkInterfacePermissionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateNetworkInterfacePermissionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateNetworkInterfacePermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNetworkInterfacePermission'
type EC2_CreateNetworkInterfacePermission_Call struct {
	*mock.Call
}

// CreateNetworkInterfacePermission is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateNetworkInterfacePermissionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateNetworkInterfacePermission(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateNetworkInterfacePermission_Call {
	return &EC2_CreateNetworkInterfacePermission_Call{Call: _e.mock.On("CreateNetworkInterfacePermission",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateNetworkInterfacePermission_Call) Run(run func(ctx context.Context, params *ec2.CreateNetworkInterfacePermissionInput, optFns ...func(*ec2.Options))) *EC2_CreateNetworkInterfacePermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateNetworkInterfacePermissionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateNetworkInterfacePermission_Call) Return(_a0 *ec2.CreateNetworkInterfacePermissionOutput, _a1 error) *EC2_CreateNetworkInterfacePermission_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateNetworkInterfacePermission_Call) RunAndReturn(run func(context.Context, *ec2.CreateNetworkInterfacePermissionInput, ...func(*ec2.Options)) (*ec2.CreateNetworkInterfacePermissionOutput, error)) *EC2_CreateNetworkInterfacePermission_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePlacementGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreatePlacementGroup(ctx context.Context, params *ec2.CreatePlacementGroupInput, optFns ...func(*ec2.Options)) (*ec2.CreatePlacementGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreatePlacementGroup")
	}

	var r0 *ec2.CreatePlacementGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreatePlacementGroupInput, ...func(*ec2.Options)) (*ec2.CreatePlacementGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreatePlacementGroupInput, ...func(*ec2.Options)) *ec2.CreatePlacementGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreatePlacementGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreatePlacementGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreatePlacementGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePlacementGroup'
type EC2_CreatePlacementGroup_Call struct {
	*mock.Call
}

// CreatePlacementGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreatePlacementGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreatePlacementGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreatePlacementGroup_Call {
	return &EC2_CreatePlacementGroup_Call{Call: _e.mock.On("CreatePlacementGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreatePlacementGroup_Call) Run(run func(ctx context.Context, params *ec2.CreatePlacementGroupInput, optFns ...func(*ec2.Options))) *EC2_CreatePlacementGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreatePlacementGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreatePlacementGroup_Call) Return(_a0 *ec2.CreatePlacementGroupOutput, _a1 error) *EC2_CreatePlacementGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreatePlacementGroup_Call) RunAndReturn(run func(context.Context, *ec2.CreatePlacementGroupInput, ...func(*ec2.Options)) (*ec2.CreatePlacementGroupOutput, error)) *EC2_CreatePlacementGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePublicIpv4Pool provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreatePublicIpv4Pool(ctx context.Context, params *ec2.CreatePublicIpv4PoolInput, optFns ...func(*ec2.Options)) (*ec2.CreatePublicIpv4PoolOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreatePublicIpv4Pool")
	}

	var r0 *ec2.CreatePublicIpv4PoolOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreatePublicIpv4PoolInput, ...func(*ec2.Options)) (*ec2.CreatePublicIpv4PoolOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreatePublicIpv4PoolInput, ...func(*ec2.Options)) *ec2.CreatePublicIpv4PoolOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreatePublicIpv4PoolOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreatePublicIpv4PoolInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreatePublicIpv4Pool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePublicIpv4Pool'
type EC2_CreatePublicIpv4Pool_Call struct {
	*mock.Call
}

// CreatePublicIpv4Pool is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreatePublicIpv4PoolInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreatePublicIpv4Pool(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreatePublicIpv4Pool_Call {
	return &EC2_CreatePublicIpv4Pool_Call{Call: _e.mock.On("CreatePublicIpv4Pool",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreatePublicIpv4Pool_Call) Run(run func(ctx context.Context, params *ec2.CreatePublicIpv4PoolInput, optFns ...func(*ec2.Options))) *EC2_CreatePublicIpv4Pool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreatePublicIpv4PoolInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreatePublicIpv4Pool_Call) Return(_a0 *ec2.CreatePublicIpv4PoolOutput, _a1 error) *EC2_CreatePublicIpv4Pool_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreatePublicIpv4Pool_Call) RunAndReturn(run func(context.Context, *ec2.CreatePublicIpv4PoolInput, ...func(*ec2.Options)) (*ec2.CreatePublicIpv4PoolOutput, error)) *EC2_CreatePublicIpv4Pool_Call {
	_c.Call.Return(run)
	return _c
}

// CreateReplaceRootVolumeTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateReplaceRootVolumeTask(ctx context.Context, params *ec2.CreateReplaceRootVolumeTaskInput, optFns ...func(*ec2.Options)) (*ec2.CreateReplaceRootVolumeTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateReplaceRootVolumeTask")
	}

	var r0 *ec2.CreateReplaceRootVolumeTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateReplaceRootVolumeTaskInput, ...func(*ec2.Options)) (*ec2.CreateReplaceRootVolumeTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateReplaceRootVolumeTaskInput, ...func(*ec2.Options)) *ec2.CreateReplaceRootVolumeTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateReplaceRootVolumeTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateReplaceRootVolumeTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateReplaceRootVolumeTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateReplaceRootVolumeTask'
type EC2_CreateReplaceRootVolumeTask_Call struct {
	*mock.Call
}

// CreateReplaceRootVolumeTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateReplaceRootVolumeTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateReplaceRootVolumeTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateReplaceRootVolumeTask_Call {
	return &EC2_CreateReplaceRootVolumeTask_Call{Call: _e.mock.On("CreateReplaceRootVolumeTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateReplaceRootVolumeTask_Call) Run(run func(ctx context.Context, params *ec2.CreateReplaceRootVolumeTaskInput, optFns ...func(*ec2.Options))) *EC2_CreateReplaceRootVolumeTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateReplaceRootVolumeTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateReplaceRootVolumeTask_Call) Return(_a0 *ec2.CreateReplaceRootVolumeTaskOutput, _a1 error) *EC2_CreateReplaceRootVolumeTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateReplaceRootVolumeTask_Call) RunAndReturn(run func(context.Context, *ec2.CreateReplaceRootVolumeTaskInput, ...func(*ec2.Options)) (*ec2.CreateReplaceRootVolumeTaskOutput, error)) *EC2_CreateReplaceRootVolumeTask_Call {
	_c.Call.Return(run)
	return _c
}

// CreateReservedInstancesListing provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateReservedInstancesListing(ctx context.Context, params *ec2.CreateReservedInstancesListingInput, optFns ...func(*ec2.Options)) (*ec2.CreateReservedInstancesListingOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateReservedInstancesListing")
	}

	var r0 *ec2.CreateReservedInstancesListingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateReservedInstancesListingInput, ...func(*ec2.Options)) (*ec2.CreateReservedInstancesListingOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateReservedInstancesListingInput, ...func(*ec2.Options)) *ec2.CreateReservedInstancesListingOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateReservedInstancesListingOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateReservedInstancesListingInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateReservedInstancesListing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateReservedInstancesListing'
type EC2_CreateReservedInstancesListing_Call struct {
	*mock.Call
}

// CreateReservedInstancesListing is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateReservedInstancesListingInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateReservedInstancesListing(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateReservedInstancesListing_Call {
	return &EC2_CreateReservedInstancesListing_Call{Call: _e.mock.On("CreateReservedInstancesListing",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateReservedInstancesListing_Call) Run(run func(ctx context.Context, params *ec2.CreateReservedInstancesListingInput, optFns ...func(*ec2.Options))) *EC2_CreateReservedInstancesListing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateReservedInstancesListingInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateReservedInstancesListing_Call) Return(_a0 *ec2.CreateReservedInstancesListingOutput, _a1 error) *EC2_CreateReservedInstancesListing_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateReservedInstancesListing_Call) RunAndReturn(run func(context.Context, *ec2.CreateReservedInstancesListingInput, ...func(*ec2.Options)) (*ec2.CreateReservedInstancesListingOutput, error)) *EC2_CreateReservedInstancesListing_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRestoreImageTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateRestoreImageTask(ctx context.Context, params *ec2.CreateRestoreImageTaskInput, optFns ...func(*ec2.Options)) (*ec2.CreateRestoreImageTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateRestoreImageTask")
	}

	var r0 *ec2.CreateRestoreImageTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRestoreImageTaskInput, ...func(*ec2.Options)) (*ec2.CreateRestoreImageTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRestoreImageTaskInput, ...func(*ec2.Options)) *ec2.CreateRestoreImageTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRestoreImageTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateRestoreImageTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateRestoreImageTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRestoreImageTask'
type EC2_CreateRestoreImageTask_Call struct {
	*mock.Call
}

// CreateRestoreImageTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateRestoreImageTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateRestoreImageTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateRestoreImageTask_Call {
	return &EC2_CreateRestoreImageTask_Call{Call: _e.mock.On("CreateRestoreImageTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateRestoreImageTask_Call) Run(run func(ctx context.Context, params *ec2.CreateRestoreImageTaskInput, optFns ...func(*ec2.Options))) *EC2_CreateRestoreImageTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateRestoreImageTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateRestoreImageTask_Call) Return(_a0 *ec2.CreateRestoreImageTaskOutput, _a1 error) *EC2_CreateRestoreImageTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateRestoreImageTask_Call) RunAndReturn(run func(context.Context, *ec2.CreateRestoreImageTaskInput, ...func(*ec2.Options)) (*ec2.CreateRestoreImageTaskOutput, error)) *EC2_CreateRestoreImageTask_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateRoute(ctx context.Context, params *ec2.CreateRouteInput, optFns ...func(*ec2.Options)) (*ec2.CreateRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateRoute")
	}

	var r0 *ec2.CreateRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteInput, ...func(*ec2.Options)) (*ec2.CreateRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteInput, ...func(*ec2.Options)) *ec2.CreateRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoute'
type EC2_CreateRoute_Call struct {
	*mock.Call
}

// CreateRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateRoute_Call {
	return &EC2_CreateRoute_Call{Call: _e.mock.On("CreateRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateRoute_Call) Run(run func(ctx context.Context, params *ec2.CreateRouteInput, optFns ...func(*ec2.Options))) *EC2_CreateRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateRoute_Call) Return(_a0 *ec2.CreateRouteOutput, _a1 error) *EC2_CreateRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateRoute_Call) RunAndReturn(run func(context.Context, *ec2.CreateRouteInput, ...func(*ec2.Options)) (*ec2.CreateRouteOutput, error)) *EC2_CreateRoute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRouteServer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateRouteServer(ctx context.Context, params *ec2.CreateRouteServerInput, optFns ...func(*ec2.Options)) (*ec2.CreateRouteServerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateRouteServer")
	}

	var r0 *ec2.CreateRouteServerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteServerInput, ...func(*ec2.Options)) (*ec2.CreateRouteServerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteServerInput, ...func(*ec2.Options)) *ec2.CreateRouteServerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteServerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateRouteServerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateRouteServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRouteServer'
type EC2_CreateRouteServer_Call struct {
	*mock.Call
}

// CreateRouteServer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateRouteServerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateRouteServer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateRouteServer_Call {
	return &EC2_CreateRouteServer_Call{Call: _e.mock.On("CreateRouteServer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateRouteServer_Call) Run(run func(ctx context.Context, params *ec2.CreateRouteServerInput, optFns ...func(*ec2.Options))) *EC2_CreateRouteServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateRouteServerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateRouteServer_Call) Return(_a0 *ec2.CreateRouteServerOutput, _a1 error) *EC2_CreateRouteServer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateRouteServer_Call) RunAndReturn(run func(context.Context, *ec2.CreateRouteServerInput, ...func(*ec2.Options)) (*ec2.CreateRouteServerOutput, error)) *EC2_CreateRouteServer_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRouteServerEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateRouteServerEndpoint(ctx context.Context, params *ec2.CreateRouteServerEndpointInput, optFns ...func(*ec2.Options)) (*ec2.CreateRouteServerEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateRouteServerEndpoint")
	}

	var r0 *ec2.CreateRouteServerEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteServerEndpointInput, ...func(*ec2.Options)) (*ec2.CreateRouteServerEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteServerEndpointInput, ...func(*ec2.Options)) *ec2.CreateRouteServerEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteServerEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateRouteServerEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateRouteServerEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRouteServerEndpoint'
type EC2_CreateRouteServerEndpoint_Call struct {
	*mock.Call
}

// CreateRouteServerEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateRouteServerEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateRouteServerEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateRouteServerEndpoint_Call {
	return &EC2_CreateRouteServerEndpoint_Call{Call: _e.mock.On("CreateRouteServerEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateRouteServerEndpoint_Call) Run(run func(ctx context.Context, params *ec2.CreateRouteServerEndpointInput, optFns ...func(*ec2.Options))) *EC2_CreateRouteServerEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateRouteServerEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateRouteServerEndpoint_Call) Return(_a0 *ec2.CreateRouteServerEndpointOutput, _a1 error) *EC2_CreateRouteServerEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateRouteServerEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.CreateRouteServerEndpointInput, ...func(*ec2.Options)) (*ec2.CreateRouteServerEndpointOutput, error)) *EC2_CreateRouteServerEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRouteServerPeer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateRouteServerPeer(ctx context.Context, params *ec2.CreateRouteServerPeerInput, optFns ...func(*ec2.Options)) (*ec2.CreateRouteServerPeerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateRouteServerPeer")
	}

	var r0 *ec2.CreateRouteServerPeerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteServerPeerInput, ...func(*ec2.Options)) (*ec2.CreateRouteServerPeerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteServerPeerInput, ...func(*ec2.Options)) *ec2.CreateRouteServerPeerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteServerPeerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateRouteServerPeerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateRouteServerPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRouteServerPeer'
type EC2_CreateRouteServerPeer_Call struct {
	*mock.Call
}

// CreateRouteServerPeer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateRouteServerPeerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateRouteServerPeer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateRouteServerPeer_Call {
	return &EC2_CreateRouteServerPeer_Call{Call: _e.mock.On("CreateRouteServerPeer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateRouteServerPeer_Call) Run(run func(ctx context.Context, params *ec2.CreateRouteServerPeerInput, optFns ...func(*ec2.Options))) *EC2_CreateRouteServerPeer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateRouteServerPeerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateRouteServerPeer_Call) Return(_a0 *ec2.CreateRouteServerPeerOutput, _a1 error) *EC2_CreateRouteServerPeer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateRouteServerPeer_Call) RunAndReturn(run func(context.Context, *ec2.CreateRouteServerPeerInput, ...func(*ec2.Options)) (*ec2.CreateRouteServerPeerOutput, error)) *EC2_CreateRouteServerPeer_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateRouteTable(ctx context.Context, params *ec2.CreateRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.CreateRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateRouteTable")
	}

	var r0 *ec2.CreateRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteTableInput, ...func(*ec2.Options)) (*ec2.CreateRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateRouteTableInput, ...func(*ec2.Options)) *ec2.CreateRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRouteTable'
type EC2_CreateRouteTable_Call struct {
	*mock.Call
}

// CreateRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateRouteTable_Call {
	return &EC2_CreateRouteTable_Call{Call: _e.mock.On("CreateRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateRouteTable_Call) Run(run func(ctx context.Context, params *ec2.CreateRouteTableInput, optFns ...func(*ec2.Options))) *EC2_CreateRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateRouteTable_Call) Return(_a0 *ec2.CreateRouteTableOutput, _a1 error) *EC2_CreateRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.CreateRouteTableInput, ...func(*ec2.Options)) (*ec2.CreateRouteTableOutput, error)) *EC2_CreateRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSecurityGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateSecurityGroup(ctx context.Context, params *ec2.CreateSecurityGroupInput, optFns ...func(*ec2.Options)) (*ec2.CreateSecurityGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateSecurityGroup")
	}

	var r0 *ec2.CreateSecurityGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSecurityGroupInput, ...func(*ec2.Options)) (*ec2.CreateSecurityGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSecurityGroupInput, ...func(*ec2.Options)) *ec2.CreateSecurityGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSecurityGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateSecurityGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateSecurityGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSecurityGroup'
type EC2_CreateSecurityGroup_Call struct {
	*mock.Call
}

// CreateSecurityGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateSecurityGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateSecurityGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateSecurityGroup_Call {
	return &EC2_CreateSecurityGroup_Call{Call: _e.mock.On("CreateSecurityGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateSecurityGroup_Call) Run(run func(ctx context.Context, params *ec2.CreateSecurityGroupInput, optFns ...func(*ec2.Options))) *EC2_CreateSecurityGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateSecurityGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateSecurityGroup_Call) Return(_a0 *ec2.CreateSecurityGroupOutput, _a1 error) *EC2_CreateSecurityGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateSecurityGroup_Call) RunAndReturn(run func(context.Context, *ec2.CreateSecurityGroupInput, ...func(*ec2.Options)) (*ec2.CreateSecurityGroupOutput, error)) *EC2_CreateSecurityGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSnapshot provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateSnapshot(ctx context.Context, params *ec2.CreateSnapshotInput, optFns ...func(*ec2.Options)) (*ec2.CreateSnapshotOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateSnapshot")
	}

	var r0 *ec2.CreateSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSnapshotInput, ...func(*ec2.Options)) (*ec2.CreateSnapshotOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSnapshotInput, ...func(*ec2.Options)) *ec2.CreateSnapshotOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSnapshotOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateSnapshotInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSnapshot'
type EC2_CreateSnapshot_Call struct {
	*mock.Call
}

// CreateSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateSnapshotInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateSnapshot(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateSnapshot_Call {
	return &EC2_CreateSnapshot_Call{Call: _e.mock.On("CreateSnapshot",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateSnapshot_Call) Run(run func(ctx context.Context, params *ec2.CreateSnapshotInput, optFns ...func(*ec2.Options))) *EC2_CreateSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateSnapshotInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateSnapshot_Call) Return(_a0 *ec2.CreateSnapshotOutput, _a1 error) *EC2_CreateSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateSnapshot_Call) RunAndReturn(run func(context.Context, *ec2.CreateSnapshotInput, ...func(*ec2.Options)) (*ec2.CreateSnapshotOutput, error)) *EC2_CreateSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSnapshots provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateSnapshots(ctx context.Context, params *ec2.CreateSnapshotsInput, optFns ...func(*ec2.Options)) (*ec2.CreateSnapshotsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateSnapshots")
	}

	var r0 *ec2.CreateSnapshotsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSnapshotsInput, ...func(*ec2.Options)) (*ec2.CreateSnapshotsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSnapshotsInput, ...func(*ec2.Options)) *ec2.CreateSnapshotsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSnapshotsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateSnapshotsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSnapshots'
type EC2_CreateSnapshots_Call struct {
	*mock.Call
}

// CreateSnapshots is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateSnapshotsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateSnapshots(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateSnapshots_Call {
	return &EC2_CreateSnapshots_Call{Call: _e.mock.On("CreateSnapshots",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateSnapshots_Call) Run(run func(ctx context.Context, params *ec2.CreateSnapshotsInput, optFns ...func(*ec2.Options))) *EC2_CreateSnapshots_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateSnapshotsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateSnapshots_Call) Return(_a0 *ec2.CreateSnapshotsOutput, _a1 error) *EC2_CreateSnapshots_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateSnapshots_Call) RunAndReturn(run func(context.Context, *ec2.CreateSnapshotsInput, ...func(*ec2.Options)) (*ec2.CreateSnapshotsOutput, error)) *EC2_CreateSnapshots_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSpotDatafeedSubscription provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateSpotDatafeedSubscription(ctx context.Context, params *ec2.CreateSpotDatafeedSubscriptionInput, optFns ...func(*ec2.Options)) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateSpotDatafeedSubscription")
	}

	var r0 *ec2.CreateSpotDatafeedSubscriptionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) (*ec2.CreateSpotDatafeedSubscriptionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) *ec2.CreateSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSpotDatafeedSubscriptionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateSpotDatafeedSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSpotDatafeedSubscription'
type EC2_CreateSpotDatafeedSubscription_Call struct {
	*mock.Call
}

// CreateSpotDatafeedSubscription is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateSpotDatafeedSubscriptionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateSpotDatafeedSubscription(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateSpotDatafeedSubscription_Call {
	return &EC2_CreateSpotDatafeedSubscription_Call{Call: _e.mock.On("CreateSpotDatafeedSubscription",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateSpotDatafeedSubscription_Call) Run(run func(ctx context.Context, params *ec2.CreateSpotDatafeedSubscriptionInput, optFns ...func(*ec2.Options))) *EC2_CreateSpotDatafeedSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateSpotDatafeedSubscriptionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateSpotDatafeedSubscription_Call) Return(_a0 *ec2.CreateSpotDatafeedSubscriptionOutput, _a1 error) *EC2_CreateSpotDatafeedSubscription_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateSpotDatafeedSubscription_Call) RunAndReturn(run func(context.Context, *ec2.CreateSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) (*ec2.CreateSpotDatafeedSubscriptionOutput, error)) *EC2_CreateSpotDatafeedSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// CreateStoreImageTask provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateStoreImageTask(ctx context.Context, params *ec2.CreateStoreImageTaskInput, optFns ...func(*ec2.Options)) (*ec2.CreateStoreImageTaskOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateStoreImageTask")
	}

	var r0 *ec2.CreateStoreImageTaskOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateStoreImageTaskInput, ...func(*ec2.Options)) (*ec2.CreateStoreImageTaskOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateStoreImageTaskInput, ...func(*ec2.Options)) *ec2.CreateStoreImageTaskOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateStoreImageTaskOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateStoreImageTaskInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateStoreImageTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStoreImageTask'
type EC2_CreateStoreImageTask_Call struct {
	*mock.Call
}

// CreateStoreImageTask is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateStoreImageTaskInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateStoreImageTask(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateStoreImageTask_Call {
	return &EC2_CreateStoreImageTask_Call{Call: _e.mock.On("CreateStoreImageTask",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateStoreImageTask_Call) Run(run func(ctx context.Context, params *ec2.CreateStoreImageTaskInput, optFns ...func(*ec2.Options))) *EC2_CreateStoreImageTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateStoreImageTaskInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateStoreImageTask_Call) Return(_a0 *ec2.CreateStoreImageTaskOutput, _a1 error) *EC2_CreateStoreImageTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateStoreImageTask_Call) RunAndReturn(run func(context.Context, *ec2.CreateStoreImageTaskInput, ...func(*ec2.Options)) (*ec2.CreateStoreImageTaskOutput, error)) *EC2_CreateStoreImageTask_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSubnet provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateSubnet(ctx context.Context, params *ec2.CreateSubnetInput, optFns ...func(*ec2.Options)) (*ec2.CreateSubnetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateSubnet")
	}

	var r0 *ec2.CreateSubnetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSubnetInput, ...func(*ec2.Options)) (*ec2.CreateSubnetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSubnetInput, ...func(*ec2.Options)) *ec2.CreateSubnetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSubnetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateSubnetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateSubnet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSubnet'
type EC2_CreateSubnet_Call struct {
	*mock.Call
}

// CreateSubnet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateSubnetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateSubnet(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateSubnet_Call {
	return &EC2_CreateSubnet_Call{Call: _e.mock.On("CreateSubnet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateSubnet_Call) Run(run func(ctx context.Context, params *ec2.CreateSubnetInput, optFns ...func(*ec2.Options))) *EC2_CreateSubnet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateSubnetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateSubnet_Call) Return(_a0 *ec2.CreateSubnetOutput, _a1 error) *EC2_CreateSubnet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateSubnet_Call) RunAndReturn(run func(context.Context, *ec2.CreateSubnetInput, ...func(*ec2.Options)) (*ec2.CreateSubnetOutput, error)) *EC2_CreateSubnet_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSubnetCidrReservation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateSubnetCidrReservation(ctx context.Context, params *ec2.CreateSubnetCidrReservationInput, optFns ...func(*ec2.Options)) (*ec2.CreateSubnetCidrReservationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateSubnetCidrReservation")
	}

	var r0 *ec2.CreateSubnetCidrReservationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSubnetCidrReservationInput, ...func(*ec2.Options)) (*ec2.CreateSubnetCidrReservationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateSubnetCidrReservationInput, ...func(*ec2.Options)) *ec2.CreateSubnetCidrReservationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateSubnetCidrReservationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateSubnetCidrReservationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateSubnetCidrReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSubnetCidrReservation'
type EC2_CreateSubnetCidrReservation_Call struct {
	*mock.Call
}

// CreateSubnetCidrReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateSubnetCidrReservationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateSubnetCidrReservation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateSubnetCidrReservation_Call {
	return &EC2_CreateSubnetCidrReservation_Call{Call: _e.mock.On("CreateSubnetCidrReservation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateSubnetCidrReservation_Call) Run(run func(ctx context.Context, params *ec2.CreateSubnetCidrReservationInput, optFns ...func(*ec2.Options))) *EC2_CreateSubnetCidrReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateSubnetCidrReservationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateSubnetCidrReservation_Call) Return(_a0 *ec2.CreateSubnetCidrReservationOutput, _a1 error) *EC2_CreateSubnetCidrReservation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateSubnetCidrReservation_Call) RunAndReturn(run func(context.Context, *ec2.CreateSubnetCidrReservationInput, ...func(*ec2.Options)) (*ec2.CreateSubnetCidrReservationOutput, error)) *EC2_CreateSubnetCidrReservation_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTags provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTags(ctx context.Context, params *ec2.CreateTagsInput, optFns ...func(*ec2.Options)) (*ec2.CreateTagsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTags")
	}

	var r0 *ec2.CreateTagsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTagsInput, ...func(*ec2.Options)) (*ec2.CreateTagsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTagsInput, ...func(*ec2.Options)) *ec2.CreateTagsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTagsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTagsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTags'
type EC2_CreateTags_Call struct {
	*mock.Call
}

// CreateTags is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTagsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTags(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTags_Call {
	return &EC2_CreateTags_Call{Call: _e.mock.On("CreateTags",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTags_Call) Run(run func(ctx context.Context, params *ec2.CreateTagsInput, optFns ...func(*ec2.Options))) *EC2_CreateTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTagsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTags_Call) Return(_a0 *ec2.CreateTagsOutput, _a1 error) *EC2_CreateTags_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTags_Call) RunAndReturn(run func(context.Context, *ec2.CreateTagsInput, ...func(*ec2.Options)) (*ec2.CreateTagsOutput, error)) *EC2_CreateTags_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTrafficMirrorFilter provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTrafficMirrorFilter(ctx context.Context, params *ec2.CreateTrafficMirrorFilterInput, optFns ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorFilterOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTrafficMirrorFilter")
	}

	var r0 *ec2.CreateTrafficMirrorFilterOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorFilterInput, ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorFilterOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorFilterInput, ...func(*ec2.Options)) *ec2.CreateTrafficMirrorFilterOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorFilterOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTrafficMirrorFilterInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTrafficMirrorFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTrafficMirrorFilter'
type EC2_CreateTrafficMirrorFilter_Call struct {
	*mock.Call
}

// CreateTrafficMirrorFilter is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTrafficMirrorFilterInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTrafficMirrorFilter(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTrafficMirrorFilter_Call {
	return &EC2_CreateTrafficMirrorFilter_Call{Call: _e.mock.On("CreateTrafficMirrorFilter",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTrafficMirrorFilter_Call) Run(run func(ctx context.Context, params *ec2.CreateTrafficMirrorFilterInput, optFns ...func(*ec2.Options))) *EC2_CreateTrafficMirrorFilter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTrafficMirrorFilterInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTrafficMirrorFilter_Call) Return(_a0 *ec2.CreateTrafficMirrorFilterOutput, _a1 error) *EC2_CreateTrafficMirrorFilter_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTrafficMirrorFilter_Call) RunAndReturn(run func(context.Context, *ec2.CreateTrafficMirrorFilterInput, ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorFilterOutput, error)) *EC2_CreateTrafficMirrorFilter_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTrafficMirrorFilterRule provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTrafficMirrorFilterRule(ctx context.Context, params *ec2.CreateTrafficMirrorFilterRuleInput, optFns ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTrafficMirrorFilterRule")
	}

	var r0 *ec2.CreateTrafficMirrorFilterRuleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorFilterRuleOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) *ec2.CreateTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorFilterRuleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTrafficMirrorFilterRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTrafficMirrorFilterRule'
type EC2_CreateTrafficMirrorFilterRule_Call struct {
	*mock.Call
}

// CreateTrafficMirrorFilterRule is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTrafficMirrorFilterRuleInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTrafficMirrorFilterRule(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTrafficMirrorFilterRule_Call {
	return &EC2_CreateTrafficMirrorFilterRule_Call{Call: _e.mock.On("CreateTrafficMirrorFilterRule",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTrafficMirrorFilterRule_Call) Run(run func(ctx context.Context, params *ec2.CreateTrafficMirrorFilterRuleInput, optFns ...func(*ec2.Options))) *EC2_CreateTrafficMirrorFilterRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTrafficMirrorFilterRuleInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTrafficMirrorFilterRule_Call) Return(_a0 *ec2.CreateTrafficMirrorFilterRuleOutput, _a1 error) *EC2_CreateTrafficMirrorFilterRule_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTrafficMirrorFilterRule_Call) RunAndReturn(run func(context.Context, *ec2.CreateTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorFilterRuleOutput, error)) *EC2_CreateTrafficMirrorFilterRule_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTrafficMirrorSession provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTrafficMirrorSession(ctx context.Context, params *ec2.CreateTrafficMirrorSessionInput, optFns ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorSessionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTrafficMirrorSession")
	}

	var r0 *ec2.CreateTrafficMirrorSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorSessionInput, ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorSessionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorSessionInput, ...func(*ec2.Options)) *ec2.CreateTrafficMirrorSessionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorSessionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTrafficMirrorSessionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTrafficMirrorSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTrafficMirrorSession'
type EC2_CreateTrafficMirrorSession_Call struct {
	*mock.Call
}

// CreateTrafficMirrorSession is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTrafficMirrorSessionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTrafficMirrorSession(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTrafficMirrorSession_Call {
	return &EC2_CreateTrafficMirrorSession_Call{Call: _e.mock.On("CreateTrafficMirrorSession",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTrafficMirrorSession_Call) Run(run func(ctx context.Context, params *ec2.CreateTrafficMirrorSessionInput, optFns ...func(*ec2.Options))) *EC2_CreateTrafficMirrorSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTrafficMirrorSessionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTrafficMirrorSession_Call) Return(_a0 *ec2.CreateTrafficMirrorSessionOutput, _a1 error) *EC2_CreateTrafficMirrorSession_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTrafficMirrorSession_Call) RunAndReturn(run func(context.Context, *ec2.CreateTrafficMirrorSessionInput, ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorSessionOutput, error)) *EC2_CreateTrafficMirrorSession_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTrafficMirrorTarget provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTrafficMirrorTarget(ctx context.Context, params *ec2.CreateTrafficMirrorTargetInput, optFns ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorTargetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTrafficMirrorTarget")
	}

	var r0 *ec2.CreateTrafficMirrorTargetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorTargetInput, ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorTargetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTrafficMirrorTargetInput, ...func(*ec2.Options)) *ec2.CreateTrafficMirrorTargetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTrafficMirrorTargetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTrafficMirrorTargetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTrafficMirrorTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTrafficMirrorTarget'
type EC2_CreateTrafficMirrorTarget_Call struct {
	*mock.Call
}

// CreateTrafficMirrorTarget is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTrafficMirrorTargetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTrafficMirrorTarget(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTrafficMirrorTarget_Call {
	return &EC2_CreateTrafficMirrorTarget_Call{Call: _e.mock.On("CreateTrafficMirrorTarget",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTrafficMirrorTarget_Call) Run(run func(ctx context.Context, params *ec2.CreateTrafficMirrorTargetInput, optFns ...func(*ec2.Options))) *EC2_CreateTrafficMirrorTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTrafficMirrorTargetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTrafficMirrorTarget_Call) Return(_a0 *ec2.CreateTrafficMirrorTargetOutput, _a1 error) *EC2_CreateTrafficMirrorTarget_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTrafficMirrorTarget_Call) RunAndReturn(run func(context.Context, *ec2.CreateTrafficMirrorTargetInput, ...func(*ec2.Options)) (*ec2.CreateTrafficMirrorTargetOutput, error)) *EC2_CreateTrafficMirrorTarget_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGateway(ctx context.Context, params *ec2.CreateTransitGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGateway")
	}

	var r0 *ec2.CreateTransitGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGateway'
type EC2_CreateTransitGateway_Call struct {
	*mock.Call
}

// CreateTransitGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGateway_Call {
	return &EC2_CreateTransitGateway_Call{Call: _e.mock.On("CreateTransitGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGateway_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGateway_Call) Return(_a0 *ec2.CreateTransitGatewayOutput, _a1 error) *EC2_CreateTransitGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGateway_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayOutput, error)) *EC2_CreateTransitGateway_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayConnect provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayConnect(ctx context.Context, params *ec2.CreateTransitGatewayConnectInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayConnectOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayConnect")
	}

	var r0 *ec2.CreateTransitGatewayConnectOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayConnectInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayConnectOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayConnectInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayConnectOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayConnectOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayConnectInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayConnect'
type EC2_CreateTransitGatewayConnect_Call struct {
	*mock.Call
}

// CreateTransitGatewayConnect is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayConnectInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayConnect(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayConnect_Call {
	return &EC2_CreateTransitGatewayConnect_Call{Call: _e.mock.On("CreateTransitGatewayConnect",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayConnect_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayConnectInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayConnect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayConnectInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayConnect_Call) Return(_a0 *ec2.CreateTransitGatewayConnectOutput, _a1 error) *EC2_CreateTransitGatewayConnect_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayConnect_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayConnectInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayConnectOutput, error)) *EC2_CreateTransitGatewayConnect_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayConnectPeer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayConnectPeer(ctx context.Context, params *ec2.CreateTransitGatewayConnectPeerInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayConnectPeerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayConnectPeer")
	}

	var r0 *ec2.CreateTransitGatewayConnectPeerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayConnectPeerInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayConnectPeerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayConnectPeerInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayConnectPeerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayConnectPeerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayConnectPeerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayConnectPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayConnectPeer'
type EC2_CreateTransitGatewayConnectPeer_Call struct {
	*mock.Call
}

// CreateTransitGatewayConnectPeer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayConnectPeerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayConnectPeer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayConnectPeer_Call {
	return &EC2_CreateTransitGatewayConnectPeer_Call{Call: _e.mock.On("CreateTransitGatewayConnectPeer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayConnectPeer_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayConnectPeerInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayConnectPeer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayConnectPeerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayConnectPeer_Call) Return(_a0 *ec2.CreateTransitGatewayConnectPeerOutput, _a1 error) *EC2_CreateTransitGatewayConnectPeer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayConnectPeer_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayConnectPeerInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayConnectPeerOutput, error)) *EC2_CreateTransitGatewayConnectPeer_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayMeteringPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayMeteringPolicy")
	}

	var r0 *ec2.CreateTransitGatewayMeteringPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayMeteringPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayMeteringPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayMeteringPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayMeteringPolicy'
type EC2_CreateTransitGatewayMeteringPolicy_Call struct {
	*mock.Call
}

// CreateTransitGatewayMeteringPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayMeteringPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayMeteringPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayMeteringPolicy_Call {
	return &EC2_CreateTransitGatewayMeteringPolicy_Call{Call: _e.mock.On("CreateTransitGatewayMeteringPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayMeteringPolicy_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayMeteringPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayMeteringPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayMeteringPolicy_Call) Return(_a0 *ec2.CreateTransitGatewayMeteringPolicyOutput, _a1 error) *EC2_CreateTransitGatewayMeteringPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayMeteringPolicy_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyOutput, error)) *EC2_CreateTransitGatewayMeteringPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayMeteringPolicyEntry provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayMeteringPolicyEntry(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyEntryInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyEntryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayMeteringPolicyEntry")
	}

	var r0 *ec2.CreateTransitGatewayMeteringPolicyEntryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyEntryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayMeteringPolicyEntryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayMeteringPolicyEntryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayMeteringPolicyEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayMeteringPolicyEntry'
type EC2_CreateTransitGatewayMeteringPolicyEntry_Call struct {
	*mock.Call
}

// CreateTransitGatewayMeteringPolicyEntry is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayMeteringPolicyEntryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayMeteringPolicyEntry(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayMeteringPolicyEntry_Call {
	return &EC2_CreateTransitGatewayMeteringPolicyEntry_Call{Call: _e.mock.On("CreateTransitGatewayMeteringPolicyEntry",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayMeteringPolicyEntry_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayMeteringPolicyEntryInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayMeteringPolicyEntry_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayMeteringPolicyEntryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayMeteringPolicyEntry_Call) Return(_a0 *ec2.CreateTransitGatewayMeteringPolicyEntryOutput, _a1 error) *EC2_CreateTransitGatewayMeteringPolicyEntry_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayMeteringPolicyEntry_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMeteringPolicyEntryOutput, error)) *EC2_CreateTransitGatewayMeteringPolicyEntry_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayMulticastDomain provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayMulticastDomain(ctx context.Context, params *ec2.CreateTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayMulticastDomain")
	}

	var r0 *ec2.CreateTransitGatewayMulticastDomainOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMulticastDomainOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayMulticastDomainOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayMulticastDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayMulticastDomain'
type EC2_CreateTransitGatewayMulticastDomain_Call struct {
	*mock.Call
}

// CreateTransitGatewayMulticastDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayMulticastDomainInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayMulticastDomain(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayMulticastDomain_Call {
	return &EC2_CreateTransitGatewayMulticastDomain_Call{Call: _e.mock.On("CreateTransitGatewayMulticastDomain",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayMulticastDomain_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayMulticastDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayMulticastDomainInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayMulticastDomain_Call) Return(_a0 *ec2.CreateTransitGatewayMulticastDomainOutput, _a1 error) *EC2_CreateTransitGatewayMulticastDomain_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayMulticastDomain_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayMulticastDomainOutput, error)) *EC2_CreateTransitGatewayMulticastDomain_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayPeeringAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayPeeringAttachment(ctx context.Context, params *ec2.CreateTransitGatewayPeeringAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayPeeringAttachment")
	}

	var r0 *ec2.CreateTransitGatewayPeeringAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayPeeringAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayPeeringAttachment'
type EC2_CreateTransitGatewayPeeringAttachment_Call struct {
	*mock.Call
}

// CreateTransitGatewayPeeringAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayPeeringAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayPeeringAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayPeeringAttachment_Call {
	return &EC2_CreateTransitGatewayPeeringAttachment_Call{Call: _e.mock.On("CreateTransitGatewayPeeringAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayPeeringAttachment_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayPeeringAttachmentInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayPeeringAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayPeeringAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayPeeringAttachment_Call) Return(_a0 *ec2.CreateTransitGatewayPeeringAttachmentOutput, _a1 error) *EC2_CreateTransitGatewayPeeringAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayPeeringAttachment_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error)) *EC2_CreateTransitGatewayPeeringAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayPolicyTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayPolicyTable(ctx context.Context, params *ec2.CreateTransitGatewayPolicyTableInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPolicyTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayPolicyTable")
	}

	var r0 *ec2.CreateTransitGatewayPolicyTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPolicyTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayPolicyTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayPolicyTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayPolicyTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayPolicyTable'
type EC2_CreateTransitGatewayPolicyTable_Call struct {
	*mock.Call
}

// CreateTransitGatewayPolicyTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayPolicyTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayPolicyTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayPolicyTable_Call {
	return &EC2_CreateTransitGatewayPolicyTable_Call{Call: _e.mock.On("CreateTransitGatewayPolicyTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayPolicyTable_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayPolicyTableInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayPolicyTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayPolicyTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayPolicyTable_Call) Return(_a0 *ec2.CreateTransitGatewayPolicyTableOutput, _a1 error) *EC2_CreateTransitGatewayPolicyTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayPolicyTable_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPolicyTableOutput, error)) *EC2_CreateTransitGatewayPolicyTable_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayPrefixListReference provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayPrefixListReference(ctx context.Context, params *ec2.CreateTransitGatewayPrefixListReferenceInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayPrefixListReference")
	}

	var r0 *ec2.CreateTransitGatewayPrefixListReferenceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayPrefixListReference_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayPrefixListReference'
type EC2_CreateTransitGatewayPrefixListReference_Call struct {
	*mock.Call
}

// CreateTransitGatewayPrefixListReference is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayPrefixListReferenceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayPrefixListReference(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayPrefixListReference_Call {
	return &EC2_CreateTransitGatewayPrefixListReference_Call{Call: _e.mock.On("CreateTransitGatewayPrefixListReference",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayPrefixListReference_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayPrefixListReferenceInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayPrefixListReference_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayPrefixListReferenceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayPrefixListReference_Call) Return(_a0 *ec2.CreateTransitGatewayPrefixListReferenceOutput, _a1 error) *EC2_CreateTransitGatewayPrefixListReference_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayPrefixListReference_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error)) *EC2_CreateTransitGatewayPrefixListReference_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayRoute(ctx context.Context, params *ec2.CreateTransitGatewayRouteInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayRoute")
	}

	var r0 *ec2.CreateTransitGatewayRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayRouteInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayRouteInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayRoute'
type EC2_CreateTransitGatewayRoute_Call struct {
	*mock.Call
}

// CreateTransitGatewayRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayRoute_Call {
	return &EC2_CreateTransitGatewayRoute_Call{Call: _e.mock.On("CreateTransitGatewayRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayRoute_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayRouteInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayRoute_Call) Return(_a0 *ec2.CreateTransitGatewayRouteOutput, _a1 error) *EC2_CreateTransitGatewayRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayRoute_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayRouteInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteOutput, error)) *EC2_CreateTransitGatewayRoute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayRouteTable(ctx context.Context, params *ec2.CreateTransitGatewayRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayRouteTable")
	}

	var r0 *ec2.CreateTransitGatewayRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayRouteTableInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayRouteTable'
type EC2_CreateTransitGatewayRouteTable_Call struct {
	*mock.Call
}

// CreateTransitGatewayRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayRouteTable_Call {
	return &EC2_CreateTransitGatewayRouteTable_Call{Call: _e.mock.On("CreateTransitGatewayRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayRouteTable_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayRouteTableInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayRouteTable_Call) Return(_a0 *ec2.CreateTransitGatewayRouteTableOutput, _a1 error) *EC2_CreateTransitGatewayRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteTableOutput, error)) *EC2_CreateTransitGatewayRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayRouteTableAnnouncement provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayRouteTableAnnouncement(ctx context.Context, params *ec2.CreateTransitGatewayRouteTableAnnouncementInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayRouteTableAnnouncement")
	}

	var r0 *ec2.CreateTransitGatewayRouteTableAnnouncementOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayRouteTableAnnouncementInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayRouteTableAnnouncementInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayRouteTableAnnouncementOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayRouteTableAnnouncementInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayRouteTableAnnouncement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayRouteTableAnnouncement'
type EC2_CreateTransitGatewayRouteTableAnnouncement_Call struct {
	*mock.Call
}

// CreateTransitGatewayRouteTableAnnouncement is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayRouteTableAnnouncementInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayRouteTableAnnouncement(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayRouteTableAnnouncement_Call {
	return &EC2_CreateTransitGatewayRouteTableAnnouncement_Call{Call: _e.mock.On("CreateTransitGatewayRouteTableAnnouncement",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayRouteTableAnnouncement_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayRouteTableAnnouncementInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayRouteTableAnnouncement_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayRouteTableAnnouncementInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayRouteTableAnnouncement_Call) Return(_a0 *ec2.CreateTransitGatewayRouteTableAnnouncementOutput, _a1 error) *EC2_CreateTransitGatewayRouteTableAnnouncement_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayRouteTableAnnouncement_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayRouteTableAnnouncementInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error)) *EC2_CreateTransitGatewayRouteTableAnnouncement_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransitGatewayVpcAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateTransitGatewayVpcAttachment(ctx context.Context, params *ec2.CreateTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateTransitGatewayVpcAttachment")
	}

	var r0 *ec2.CreateTransitGatewayVpcAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) *ec2.CreateTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateTransitGatewayVpcAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateTransitGatewayVpcAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransitGatewayVpcAttachment'
type EC2_CreateTransitGatewayVpcAttachment_Call struct {
	*mock.Call
}

// CreateTransitGatewayVpcAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateTransitGatewayVpcAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateTransitGatewayVpcAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateTransitGatewayVpcAttachment_Call {
	return &EC2_CreateTransitGatewayVpcAttachment_Call{Call: _e.mock.On("CreateTransitGatewayVpcAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateTransitGatewayVpcAttachment_Call) Run(run func(ctx context.Context, params *ec2.CreateTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options))) *EC2_CreateTransitGatewayVpcAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateTransitGatewayVpcAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateTransitGatewayVpcAttachment_Call) Return(_a0 *ec2.CreateTransitGatewayVpcAttachmentOutput, _a1 error) *EC2_CreateTransitGatewayVpcAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateTransitGatewayVpcAttachment_Call) RunAndReturn(run func(context.Context, *ec2.CreateTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error)) *EC2_CreateTransitGatewayVpcAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVerifiedAccessEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVerifiedAccessEndpoint(ctx context.Context, params *ec2.CreateVerifiedAccessEndpointInput, optFns ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVerifiedAccessEndpoint")
	}

	var r0 *ec2.CreateVerifiedAccessEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVerifiedAccessEndpointInput, ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVerifiedAccessEndpointInput, ...func(*ec2.Options)) *ec2.CreateVerifiedAccessEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVerifiedAccessEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVerifiedAccessEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVerifiedAccessEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVerifiedAccessEndpoint'
type EC2_CreateVerifiedAccessEndpoint_Call struct {
	*mock.Call
}

// CreateVerifiedAccessEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVerifiedAccessEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVerifiedAccessEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVerifiedAccessEndpoint_Call {
	return &EC2_CreateVerifiedAccessEndpoint_Call{Call: _e.mock.On("CreateVerifiedAccessEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVerifiedAccessEndpoint_Call) Run(run func(ctx context.Context, params *ec2.CreateVerifiedAccessEndpointInput, optFns ...func(*ec2.Options))) *EC2_CreateVerifiedAccessEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVerifiedAccessEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVerifiedAccessEndpoint_Call) Return(_a0 *ec2.CreateVerifiedAccessEndpointOutput, _a1 error) *EC2_CreateVerifiedAccessEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVerifiedAccessEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.CreateVerifiedAccessEndpointInput, ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessEndpointOutput, error)) *EC2_CreateVerifiedAccessEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVerifiedAccessGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVerifiedAccessGroup(ctx context.Context, params *ec2.CreateVerifiedAccessGroupInput, optFns ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVerifiedAccessGroup")
	}

	var r0 *ec2.CreateVerifiedAccessGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVerifiedAccessGroupInput, ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVerifiedAccessGroupInput, ...func(*ec2.Options)) *ec2.CreateVerifiedAccessGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVerifiedAccessGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVerifiedAccessGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVerifiedAccessGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVerifiedAccessGroup'
type EC2_CreateVerifiedAccessGroup_Call struct {
	*mock.Call
}

// CreateVerifiedAccessGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVerifiedAccessGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVerifiedAccessGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVerifiedAccessGroup_Call {
	return &EC2_CreateVerifiedAccessGroup_Call{Call: _e.mock.On("CreateVerifiedAccessGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVerifiedAccessGroup_Call) Run(run func(ctx context.Context, params *ec2.CreateVerifiedAccessGroupInput, optFns ...func(*ec2.Options))) *EC2_CreateVerifiedAccessGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVerifiedAccessGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVerifiedAccessGroup_Call) Return(_a0 *ec2.CreateVerifiedAccessGroupOutput, _a1 error) *EC2_CreateVerifiedAccessGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVerifiedAccessGroup_Call) RunAndReturn(run func(context.Context, *ec2.CreateVerifiedAccessGroupInput, ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessGroupOutput, error)) *EC2_CreateVerifiedAccessGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVerifiedAccessInstance provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVerifiedAccessInstance(ctx context.Context, params *ec2.CreateVerifiedAccessInstanceInput, optFns ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessInstanceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVerifiedAccessInstance")
	}

	var r0 *ec2.CreateVerifiedAccessInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVerifiedAccessInstanceInput, ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessInstanceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVerifiedAccessInstanceInput, ...func(*ec2.Options)) *ec2.CreateVerifiedAccessInstanceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVerifiedAccessInstanceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVerifiedAccessInstanceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVerifiedAccessInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVerifiedAccessInstance'
type EC2_CreateVerifiedAccessInstance_Call struct {
	*mock.Call
}

// CreateVerifiedAccessInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVerifiedAccessInstanceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVerifiedAccessInstance(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVerifiedAccessInstance_Call {
	return &EC2_CreateVerifiedAccessInstance_Call{Call: _e.mock.On("CreateVerifiedAccessInstance",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVerifiedAccessInstance_Call) Run(run func(ctx context.Context, params *ec2.CreateVerifiedAccessInstanceInput, optFns ...func(*ec2.Options))) *EC2_CreateVerifiedAccessInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVerifiedAccessInstanceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVerifiedAccessInstance_Call) Return(_a0 *ec2.CreateVerifiedAccessInstanceOutput, _a1 error) *EC2_CreateVerifiedAccessInstance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVerifiedAccessInstance_Call) RunAndReturn(run func(context.Context, *ec2.CreateVerifiedAccessInstanceInput, ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessInstanceOutput, error)) *EC2_CreateVerifiedAccessInstance_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVerifiedAccessTrustProvider provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVerifiedAccessTrustProvider(ctx context.Context, params *ec2.CreateVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessTrustProviderOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVerifiedAccessTrustProvider")
	}

	var r0 *ec2.CreateVerifiedAccessTrustProviderOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessTrustProviderOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) *ec2.CreateVerifiedAccessTrustProviderOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVerifiedAccessTrustProviderOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVerifiedAccessTrustProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVerifiedAccessTrustProvider'
type EC2_CreateVerifiedAccessTrustProvider_Call struct {
	*mock.Call
}

// CreateVerifiedAccessTrustProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVerifiedAccessTrustProviderInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVerifiedAccessTrustProvider(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVerifiedAccessTrustProvider_Call {
	return &EC2_CreateVerifiedAccessTrustProvider_Call{Call: _e.mock.On("CreateVerifiedAccessTrustProvider",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVerifiedAccessTrustProvider_Call) Run(run func(ctx context.Context, params *ec2.CreateVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options))) *EC2_CreateVerifiedAccessTrustProvider_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVerifiedAccessTrustProviderInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVerifiedAccessTrustProvider_Call) Return(_a0 *ec2.CreateVerifiedAccessTrustProviderOutput, _a1 error) *EC2_CreateVerifiedAccessTrustProvider_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVerifiedAccessTrustProvider_Call) RunAndReturn(run func(context.Context, *ec2.CreateVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.CreateVerifiedAccessTrustProviderOutput, error)) *EC2_CreateVerifiedAccessTrustProvider_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVolume provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVolume(ctx context.Context, params *ec2.CreateVolumeInput, optFns ...func(*ec2.Options)) (*ec2.CreateVolumeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVolume")
	}

	var r0 *ec2.CreateVolumeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVolumeInput, ...func(*ec2.Options)) (*ec2.CreateVolumeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVolumeInput, ...func(*ec2.Options)) *ec2.CreateVolumeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVolumeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVolumeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVolume'
type EC2_CreateVolume_Call struct {
	*mock.Call
}

// CreateVolume is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVolumeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVolume(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVolume_Call {
	return &EC2_CreateVolume_Call{Call: _e.mock.On("CreateVolume",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVolume_Call) Run(run func(ctx context.Context, params *ec2.CreateVolumeInput, optFns ...func(*ec2.Options))) *EC2_CreateVolume_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVolumeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVolume_Call) Return(_a0 *ec2.CreateVolumeOutput, _a1 error) *EC2_CreateVolume_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVolume_Call) RunAndReturn(run func(context.Context, *ec2.CreateVolumeInput, ...func(*ec2.Options)) (*ec2.CreateVolumeOutput, error)) *EC2_CreateVolume_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpc(ctx context.Context, params *ec2.CreateVpcInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpc")
	}

	var r0 *ec2.CreateVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcInput, ...func(*ec2.Options)) (*ec2.CreateVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcInput, ...func(*ec2.Options)) *ec2.CreateVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpc'
type EC2_CreateVpc_Call struct {
	*mock.Call
}

// CreateVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpc_Call {
	return &EC2_CreateVpc_Call{Call: _e.mock.On("CreateVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpc_Call) Run(run func(ctx context.Context, params *ec2.CreateVpcInput, optFns ...func(*ec2.Options))) *EC2_CreateVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpc_Call) Return(_a0 *ec2.CreateVpcOutput, _a1 error) *EC2_CreateVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpc_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpcInput, ...func(*ec2.Options)) (*ec2.CreateVpcOutput, error)) *EC2_CreateVpc_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpcBlockPublicAccessExclusion provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpcBlockPublicAccessExclusion(ctx context.Context, params *ec2.CreateVpcBlockPublicAccessExclusionInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcBlockPublicAccessExclusionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpcBlockPublicAccessExclusion")
	}

	var r0 *ec2.CreateVpcBlockPublicAccessExclusionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) (*ec2.CreateVpcBlockPublicAccessExclusionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) *ec2.CreateVpcBlockPublicAccessExclusionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcBlockPublicAccessExclusionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpcBlockPublicAccessExclusion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpcBlockPublicAccessExclusion'
type EC2_CreateVpcBlockPublicAccessExclusion_Call struct {
	*mock.Call
}

// CreateVpcBlockPublicAccessExclusion is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpcBlockPublicAccessExclusionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpcBlockPublicAccessExclusion(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpcBlockPublicAccessExclusion_Call {
	return &EC2_CreateVpcBlockPublicAccessExclusion_Call{Call: _e.mock.On("CreateVpcBlockPublicAccessExclusion",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpcBlockPublicAccessExclusion_Call) Run(run func(ctx context.Context, params *ec2.CreateVpcBlockPublicAccessExclusionInput, optFns ...func(*ec2.Options))) *EC2_CreateVpcBlockPublicAccessExclusion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpcBlockPublicAccessExclusionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpcBlockPublicAccessExclusion_Call) Return(_a0 *ec2.CreateVpcBlockPublicAccessExclusionOutput, _a1 error) *EC2_CreateVpcBlockPublicAccessExclusion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpcBlockPublicAccessExclusion_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) (*ec2.CreateVpcBlockPublicAccessExclusionOutput, error)) *EC2_CreateVpcBlockPublicAccessExclusion_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpcEncryptionControl provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpcEncryptionControl(ctx context.Context, params *ec2.CreateVpcEncryptionControlInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcEncryptionControlOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpcEncryptionControl")
	}

	var r0 *ec2.CreateVpcEncryptionControlOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.CreateVpcEncryptionControlOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEncryptionControlInput, ...func(*ec2.Options)) *ec2.CreateVpcEncryptionControlOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEncryptionControlOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpcEncryptionControlInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpcEncryptionControl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpcEncryptionControl'
type EC2_CreateVpcEncryptionControl_Call struct {
	*mock.Call
}

// CreateVpcEncryptionControl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpcEncryptionControlInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpcEncryptionControl(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpcEncryptionControl_Call {
	return &EC2_CreateVpcEncryptionControl_Call{Call: _e.mock.On("CreateVpcEncryptionControl",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpcEncryptionControl_Call) Run(run func(ctx context.Context, params *ec2.CreateVpcEncryptionControlInput, optFns ...func(*ec2.Options))) *EC2_CreateVpcEncryptionControl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpcEncryptionControlInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpcEncryptionControl_Call) Return(_a0 *ec2.CreateVpcEncryptionControlOutput, _a1 error) *EC2_CreateVpcEncryptionControl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpcEncryptionControl_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.CreateVpcEncryptionControlOutput, error)) *EC2_CreateVpcEncryptionControl_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpcEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpcEndpoint(ctx context.Context, params *ec2.CreateVpcEndpointInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpcEndpoint")
	}

	var r0 *ec2.CreateVpcEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointInput, ...func(*ec2.Options)) (*ec2.CreateVpcEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointInput, ...func(*ec2.Options)) *ec2.CreateVpcEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpcEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpcEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpcEndpoint'
type EC2_CreateVpcEndpoint_Call struct {
	*mock.Call
}

// CreateVpcEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpcEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpcEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpcEndpoint_Call {
	return &EC2_CreateVpcEndpoint_Call{Call: _e.mock.On("CreateVpcEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpcEndpoint_Call) Run(run func(ctx context.Context, params *ec2.CreateVpcEndpointInput, optFns ...func(*ec2.Options))) *EC2_CreateVpcEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpcEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpcEndpoint_Call) Return(_a0 *ec2.CreateVpcEndpointOutput, _a1 error) *EC2_CreateVpcEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpcEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpcEndpointInput, ...func(*ec2.Options)) (*ec2.CreateVpcEndpointOutput, error)) *EC2_CreateVpcEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpcEndpointConnectionNotification provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpcEndpointConnectionNotification(ctx context.Context, params *ec2.CreateVpcEndpointConnectionNotificationInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpcEndpointConnectionNotification")
	}

	var r0 *ec2.CreateVpcEndpointConnectionNotificationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointConnectionNotificationInput, ...func(*ec2.Options)) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointConnectionNotificationInput, ...func(*ec2.Options)) *ec2.CreateVpcEndpointConnectionNotificationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointConnectionNotificationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpcEndpointConnectionNotificationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpcEndpointConnectionNotification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpcEndpointConnectionNotification'
type EC2_CreateVpcEndpointConnectionNotification_Call struct {
	*mock.Call
}

// CreateVpcEndpointConnectionNotification is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpcEndpointConnectionNotificationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpcEndpointConnectionNotification(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpcEndpointConnectionNotification_Call {
	return &EC2_CreateVpcEndpointConnectionNotification_Call{Call: _e.mock.On("CreateVpcEndpointConnectionNotification",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpcEndpointConnectionNotification_Call) Run(run func(ctx context.Context, params *ec2.CreateVpcEndpointConnectionNotificationInput, optFns ...func(*ec2.Options))) *EC2_CreateVpcEndpointConnectionNotification_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpcEndpointConnectionNotificationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpcEndpointConnectionNotification_Call) Return(_a0 *ec2.CreateVpcEndpointConnectionNotificationOutput, _a1 error) *EC2_CreateVpcEndpointConnectionNotification_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpcEndpointConnectionNotification_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpcEndpointConnectionNotificationInput, ...func(*ec2.Options)) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error)) *EC2_CreateVpcEndpointConnectionNotification_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpcEndpointServiceConfiguration provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpcEndpointServiceConfiguration(ctx context.Context, params *ec2.CreateVpcEndpointServiceConfigurationInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpcEndpointServiceConfiguration")
	}

	var r0 *ec2.CreateVpcEndpointServiceConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointServiceConfigurationInput, ...func(*ec2.Options)) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcEndpointServiceConfigurationInput, ...func(*ec2.Options)) *ec2.CreateVpcEndpointServiceConfigurationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcEndpointServiceConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpcEndpointServiceConfigurationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpcEndpointServiceConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpcEndpointServiceConfiguration'
type EC2_CreateVpcEndpointServiceConfiguration_Call struct {
	*mock.Call
}

// CreateVpcEndpointServiceConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpcEndpointServiceConfigurationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpcEndpointServiceConfiguration(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpcEndpointServiceConfiguration_Call {
	return &EC2_CreateVpcEndpointServiceConfiguration_Call{Call: _e.mock.On("CreateVpcEndpointServiceConfiguration",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpcEndpointServiceConfiguration_Call) Run(run func(ctx context.Context, params *ec2.CreateVpcEndpointServiceConfigurationInput, optFns ...func(*ec2.Options))) *EC2_CreateVpcEndpointServiceConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpcEndpointServiceConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpcEndpointServiceConfiguration_Call) Return(_a0 *ec2.CreateVpcEndpointServiceConfigurationOutput, _a1 error) *EC2_CreateVpcEndpointServiceConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpcEndpointServiceConfiguration_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpcEndpointServiceConfigurationInput, ...func(*ec2.Options)) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error)) *EC2_CreateVpcEndpointServiceConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpcPeeringConnection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpcPeeringConnection(ctx context.Context, params *ec2.CreateVpcPeeringConnectionInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpcPeeringConnectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpcPeeringConnection")
	}

	var r0 *ec2.CreateVpcPeeringConnectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcPeeringConnectionInput, ...func(*ec2.Options)) (*ec2.CreateVpcPeeringConnectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpcPeeringConnectionInput, ...func(*ec2.Options)) *ec2.CreateVpcPeeringConnectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpcPeeringConnectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpcPeeringConnectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpcPeeringConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpcPeeringConnection'
type EC2_CreateVpcPeeringConnection_Call struct {
	*mock.Call
}

// CreateVpcPeeringConnection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpcPeeringConnectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpcPeeringConnection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpcPeeringConnection_Call {
	return &EC2_CreateVpcPeeringConnection_Call{Call: _e.mock.On("CreateVpcPeeringConnection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpcPeeringConnection_Call) Run(run func(ctx context.Context, params *ec2.CreateVpcPeeringConnectionInput, optFns ...func(*ec2.Options))) *EC2_CreateVpcPeeringConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpcPeeringConnectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpcPeeringConnection_Call) Return(_a0 *ec2.CreateVpcPeeringConnectionOutput, _a1 error) *EC2_CreateVpcPeeringConnection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpcPeeringConnection_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpcPeeringConnectionInput, ...func(*ec2.Options)) (*ec2.CreateVpcPeeringConnectionOutput, error)) *EC2_CreateVpcPeeringConnection_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpnConcentrator provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpnConcentrator(ctx context.Context, params *ec2.CreateVpnConcentratorInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpnConcentratorOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpnConcentrator")
	}

	var r0 *ec2.CreateVpnConcentratorOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConcentratorInput, ...func(*ec2.Options)) (*ec2.CreateVpnConcentratorOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConcentratorInput, ...func(*ec2.Options)) *ec2.CreateVpnConcentratorOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnConcentratorOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpnConcentratorInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpnConcentrator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpnConcentrator'
type EC2_CreateVpnConcentrator_Call struct {
	*mock.Call
}

// CreateVpnConcentrator is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpnConcentratorInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpnConcentrator(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpnConcentrator_Call {
	return &EC2_CreateVpnConcentrator_Call{Call: _e.mock.On("CreateVpnConcentrator",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpnConcentrator_Call) Run(run func(ctx context.Context, params *ec2.CreateVpnConcentratorInput, optFns ...func(*ec2.Options))) *EC2_CreateVpnConcentrator_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpnConcentratorInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpnConcentrator_Call) Return(_a0 *ec2.CreateVpnConcentratorOutput, _a1 error) *EC2_CreateVpnConcentrator_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpnConcentrator_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpnConcentratorInput, ...func(*ec2.Options)) (*ec2.CreateVpnConcentratorOutput, error)) *EC2_CreateVpnConcentrator_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpnConnection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpnConnection(ctx context.Context, params *ec2.CreateVpnConnectionInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpnConnectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpnConnection")
	}

	var r0 *ec2.CreateVpnConnectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConnectionInput, ...func(*ec2.Options)) (*ec2.CreateVpnConnectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConnectionInput, ...func(*ec2.Options)) *ec2.CreateVpnConnectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnConnectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpnConnectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpnConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpnConnection'
type EC2_CreateVpnConnection_Call struct {
	*mock.Call
}

// CreateVpnConnection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpnConnectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpnConnection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpnConnection_Call {
	return &EC2_CreateVpnConnection_Call{Call: _e.mock.On("CreateVpnConnection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpnConnection_Call) Run(run func(ctx context.Context, params *ec2.CreateVpnConnectionInput, optFns ...func(*ec2.Options))) *EC2_CreateVpnConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpnConnectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpnConnection_Call) Return(_a0 *ec2.CreateVpnConnectionOutput, _a1 error) *EC2_CreateVpnConnection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpnConnection_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpnConnectionInput, ...func(*ec2.Options)) (*ec2.CreateVpnConnectionOutput, error)) *EC2_CreateVpnConnection_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpnConnectionRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpnConnectionRoute(ctx context.Context, params *ec2.CreateVpnConnectionRouteInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpnConnectionRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpnConnectionRoute")
	}

	var r0 *ec2.CreateVpnConnectionRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConnectionRouteInput, ...func(*ec2.Options)) (*ec2.CreateVpnConnectionRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnConnectionRouteInput, ...func(*ec2.Options)) *ec2.CreateVpnConnectionRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnConnectionRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpnConnectionRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpnConnectionRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpnConnectionRoute'
type EC2_CreateVpnConnectionRoute_Call struct {
	*mock.Call
}

// CreateVpnConnectionRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpnConnectionRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpnConnectionRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpnConnectionRoute_Call {
	return &EC2_CreateVpnConnectionRoute_Call{Call: _e.mock.On("CreateVpnConnectionRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpnConnectionRoute_Call) Run(run func(ctx context.Context, params *ec2.CreateVpnConnectionRouteInput, optFns ...func(*ec2.Options))) *EC2_CreateVpnConnectionRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpnConnectionRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpnConnectionRoute_Call) Return(_a0 *ec2.CreateVpnConnectionRouteOutput, _a1 error) *EC2_CreateVpnConnectionRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpnConnectionRoute_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpnConnectionRouteInput, ...func(*ec2.Options)) (*ec2.CreateVpnConnectionRouteOutput, error)) *EC2_CreateVpnConnectionRoute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateVpnGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) CreateVpnGateway(ctx context.Context, params *ec2.CreateVpnGatewayInput, optFns ...func(*ec2.Options)) (*ec2.CreateVpnGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateVpnGateway")
	}

	var r0 *ec2.CreateVpnGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnGatewayInput, ...func(*ec2.Options)) (*ec2.CreateVpnGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.CreateVpnGatewayInput, ...func(*ec2.Options)) *ec2.CreateVpnGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.CreateVpnGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.CreateVpnGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_CreateVpnGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVpnGateway'
type EC2_CreateVpnGateway_Call struct {
	*mock.Call
}

// CreateVpnGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.CreateVpnGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) CreateVpnGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_CreateVpnGateway_Call {
	return &EC2_CreateVpnGateway_Call{Call: _e.mock.On("CreateVpnGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_CreateVpnGateway_Call) Run(run func(ctx context.Context, params *ec2.CreateVpnGatewayInput, optFns ...func(*ec2.Options))) *EC2_CreateVpnGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.CreateVpnGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_CreateVpnGateway_Call) Return(_a0 *ec2.CreateVpnGatewayOutput, _a1 error) *EC2_CreateVpnGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_CreateVpnGateway_Call) RunAndReturn(run func(context.Context, *ec2.CreateVpnGatewayInput, ...func(*ec2.Options)) (*ec2.CreateVpnGatewayOutput, error)) *EC2_CreateVpnGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteCapacityManagerDataExport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteCapacityManagerDataExport(ctx context.Context, params *ec2.DeleteCapacityManagerDataExportInput, optFns ...func(*ec2.Options)) (*ec2.DeleteCapacityManagerDataExportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteCapacityManagerDataExport")
	}

	var r0 *ec2.DeleteCapacityManagerDataExportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCapacityManagerDataExportInput, ...func(*ec2.Options)) (*ec2.DeleteCapacityManagerDataExportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCapacityManagerDataExportInput, ...func(*ec2.Options)) *ec2.DeleteCapacityManagerDataExportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCapacityManagerDataExportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteCapacityManagerDataExportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteCapacityManagerDataExport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCapacityManagerDataExport'
type EC2_DeleteCapacityManagerDataExport_Call struct {
	*mock.Call
}

// DeleteCapacityManagerDataExport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteCapacityManagerDataExportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteCapacityManagerDataExport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteCapacityManagerDataExport_Call {
	return &EC2_DeleteCapacityManagerDataExport_Call{Call: _e.mock.On("DeleteCapacityManagerDataExport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteCapacityManagerDataExport_Call) Run(run func(ctx context.Context, params *ec2.DeleteCapacityManagerDataExportInput, optFns ...func(*ec2.Options))) *EC2_DeleteCapacityManagerDataExport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteCapacityManagerDataExportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteCapacityManagerDataExport_Call) Return(_a0 *ec2.DeleteCapacityManagerDataExportOutput, _a1 error) *EC2_DeleteCapacityManagerDataExport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteCapacityManagerDataExport_Call) RunAndReturn(run func(context.Context, *ec2.DeleteCapacityManagerDataExportInput, ...func(*ec2.Options)) (*ec2.DeleteCapacityManagerDataExportOutput, error)) *EC2_DeleteCapacityManagerDataExport_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteCarrierGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteCarrierGateway(ctx context.Context, params *ec2.DeleteCarrierGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteCarrierGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteCarrierGateway")
	}

	var r0 *ec2.DeleteCarrierGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCarrierGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteCarrierGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCarrierGatewayInput, ...func(*ec2.Options)) *ec2.DeleteCarrierGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCarrierGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteCarrierGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteCarrierGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCarrierGateway'
type EC2_DeleteCarrierGateway_Call struct {
	*mock.Call
}

// DeleteCarrierGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteCarrierGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteCarrierGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteCarrierGateway_Call {
	return &EC2_DeleteCarrierGateway_Call{Call: _e.mock.On("DeleteCarrierGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteCarrierGateway_Call) Run(run func(ctx context.Context, params *ec2.DeleteCarrierGatewayInput, optFns ...func(*ec2.Options))) *EC2_DeleteCarrierGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteCarrierGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteCarrierGateway_Call) Return(_a0 *ec2.DeleteCarrierGatewayOutput, _a1 error) *EC2_DeleteCarrierGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteCarrierGateway_Call) RunAndReturn(run func(context.Context, *ec2.DeleteCarrierGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteCarrierGatewayOutput, error)) *EC2_DeleteCarrierGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClientVpnEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteClientVpnEndpoint(ctx context.Context, params *ec2.DeleteClientVpnEndpointInput, optFns ...func(*ec2.Options)) (*ec2.DeleteClientVpnEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteClientVpnEndpoint")
	}

	var r0 *ec2.DeleteClientVpnEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteClientVpnEndpointInput, ...func(*ec2.Options)) (*ec2.DeleteClientVpnEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteClientVpnEndpointInput, ...func(*ec2.Options)) *ec2.DeleteClientVpnEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteClientVpnEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteClientVpnEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteClientVpnEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClientVpnEndpoint'
type EC2_DeleteClientVpnEndpoint_Call struct {
	*mock.Call
}

// DeleteClientVpnEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteClientVpnEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteClientVpnEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteClientVpnEndpoint_Call {
	return &EC2_DeleteClientVpnEndpoint_Call{Call: _e.mock.On("DeleteClientVpnEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteClientVpnEndpoint_Call) Run(run func(ctx context.Context, params *ec2.DeleteClientVpnEndpointInput, optFns ...func(*ec2.Options))) *EC2_DeleteClientVpnEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteClientVpnEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteClientVpnEndpoint_Call) Return(_a0 *ec2.DeleteClientVpnEndpointOutput, _a1 error) *EC2_DeleteClientVpnEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteClientVpnEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.DeleteClientVpnEndpointInput, ...func(*ec2.Options)) (*ec2.DeleteClientVpnEndpointOutput, error)) *EC2_DeleteClientVpnEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClientVpnRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteClientVpnRoute(ctx context.Context, params *ec2.DeleteClientVpnRouteInput, optFns ...func(*ec2.Options)) (*ec2.DeleteClientVpnRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteClientVpnRoute")
	}

	var r0 *ec2.DeleteClientVpnRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteClientVpnRouteInput, ...func(*ec2.Options)) (*ec2.DeleteClientVpnRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteClientVpnRouteInput, ...func(*ec2.Options)) *ec2.DeleteClientVpnRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteClientVpnRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteClientVpnRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteClientVpnRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClientVpnRoute'
type EC2_DeleteClientVpnRoute_Call struct {
	*mock.Call
}

// DeleteClientVpnRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteClientVpnRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteClientVpnRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteClientVpnRoute_Call {
	return &EC2_DeleteClientVpnRoute_Call{Call: _e.mock.On("DeleteClientVpnRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteClientVpnRoute_Call) Run(run func(ctx context.Context, params *ec2.DeleteClientVpnRouteInput, optFns ...func(*ec2.Options))) *EC2_DeleteClientVpnRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteClientVpnRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteClientVpnRoute_Call) Return(_a0 *ec2.DeleteClientVpnRouteOutput, _a1 error) *EC2_DeleteClientVpnRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteClientVpnRoute_Call) RunAndReturn(run func(context.Context, *ec2.DeleteClientVpnRouteInput, ...func(*ec2.Options)) (*ec2.DeleteClientVpnRouteOutput, error)) *EC2_DeleteClientVpnRoute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteCoipCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteCoipCidr(ctx context.Context, params *ec2.DeleteCoipCidrInput, optFns ...func(*ec2.Options)) (*ec2.DeleteCoipCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteCoipCidr")
	}

	var r0 *ec2.DeleteCoipCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCoipCidrInput, ...func(*ec2.Options)) (*ec2.DeleteCoipCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCoipCidrInput, ...func(*ec2.Options)) *ec2.DeleteCoipCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCoipCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteCoipCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteCoipCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCoipCidr'
type EC2_DeleteCoipCidr_Call struct {
	*mock.Call
}

// DeleteCoipCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteCoipCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteCoipCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteCoipCidr_Call {
	return &EC2_DeleteCoipCidr_Call{Call: _e.mock.On("DeleteCoipCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteCoipCidr_Call) Run(run func(ctx context.Context, params *ec2.DeleteCoipCidrInput, optFns ...func(*ec2.Options))) *EC2_DeleteCoipCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteCoipCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteCoipCidr_Call) Return(_a0 *ec2.DeleteCoipCidrOutput, _a1 error) *EC2_DeleteCoipCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteCoipCidr_Call) RunAndReturn(run func(context.Context, *ec2.DeleteCoipCidrInput, ...func(*ec2.Options)) (*ec2.DeleteCoipCidrOutput, error)) *EC2_DeleteCoipCidr_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteCoipPool provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteCoipPool(ctx context.Context, params *ec2.DeleteCoipPoolInput, optFns ...func(*ec2.Options)) (*ec2.DeleteCoipPoolOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteCoipPool")
	}

	var r0 *ec2.DeleteCoipPoolOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCoipPoolInput, ...func(*ec2.Options)) (*ec2.DeleteCoipPoolOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCoipPoolInput, ...func(*ec2.Options)) *ec2.DeleteCoipPoolOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCoipPoolOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteCoipPoolInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteCoipPool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCoipPool'
type EC2_DeleteCoipPool_Call struct {
	*mock.Call
}

// DeleteCoipPool is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteCoipPoolInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteCoipPool(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteCoipPool_Call {
	return &EC2_DeleteCoipPool_Call{Call: _e.mock.On("DeleteCoipPool",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteCoipPool_Call) Run(run func(ctx context.Context, params *ec2.DeleteCoipPoolInput, optFns ...func(*ec2.Options))) *EC2_DeleteCoipPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteCoipPoolInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteCoipPool_Call) Return(_a0 *ec2.DeleteCoipPoolOutput, _a1 error) *EC2_DeleteCoipPool_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteCoipPool_Call) RunAndReturn(run func(context.Context, *ec2.DeleteCoipPoolInput, ...func(*ec2.Options)) (*ec2.DeleteCoipPoolOutput, error)) *EC2_DeleteCoipPool_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteCustomerGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteCustomerGateway(ctx context.Context, params *ec2.DeleteCustomerGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteCustomerGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteCustomerGateway")
	}

	var r0 *ec2.DeleteCustomerGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCustomerGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteCustomerGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteCustomerGatewayInput, ...func(*ec2.Options)) *ec2.DeleteCustomerGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteCustomerGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteCustomerGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteCustomerGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCustomerGateway'
type EC2_DeleteCustomerGateway_Call struct {
	*mock.Call
}

// DeleteCustomerGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteCustomerGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteCustomerGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteCustomerGateway_Call {
	return &EC2_DeleteCustomerGateway_Call{Call: _e.mock.On("DeleteCustomerGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteCustomerGateway_Call) Run(run func(ctx context.Context, params *ec2.DeleteCustomerGatewayInput, optFns ...func(*ec2.Options))) *EC2_DeleteCustomerGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteCustomerGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteCustomerGateway_Call) Return(_a0 *ec2.DeleteCustomerGatewayOutput, _a1 error) *EC2_DeleteCustomerGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteCustomerGateway_Call) RunAndReturn(run func(context.Context, *ec2.DeleteCustomerGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteCustomerGatewayOutput, error)) *EC2_DeleteCustomerGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDhcpOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteDhcpOptions(ctx context.Context, params *ec2.DeleteDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteDhcpOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteDhcpOptions")
	}

	var r0 *ec2.DeleteDhcpOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteDhcpOptionsInput, ...func(*ec2.Options)) (*ec2.DeleteDhcpOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteDhcpOptionsInput, ...func(*ec2.Options)) *ec2.DeleteDhcpOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteDhcpOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteDhcpOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteDhcpOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDhcpOptions'
type EC2_DeleteDhcpOptions_Call struct {
	*mock.Call
}

// DeleteDhcpOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteDhcpOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteDhcpOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteDhcpOptions_Call {
	return &EC2_DeleteDhcpOptions_Call{Call: _e.mock.On("DeleteDhcpOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteDhcpOptions_Call) Run(run func(ctx context.Context, params *ec2.DeleteDhcpOptionsInput, optFns ...func(*ec2.Options))) *EC2_DeleteDhcpOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteDhcpOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteDhcpOptions_Call) Return(_a0 *ec2.DeleteDhcpOptionsOutput, _a1 error) *EC2_DeleteDhcpOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteDhcpOptions_Call) RunAndReturn(run func(context.Context, *ec2.DeleteDhcpOptionsInput, ...func(*ec2.Options)) (*ec2.DeleteDhcpOptionsOutput, error)) *EC2_DeleteDhcpOptions_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteEgressOnlyInternetGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteEgressOnlyInternetGateway(ctx context.Context, params *ec2.DeleteEgressOnlyInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteEgressOnlyInternetGateway")
	}

	var r0 *ec2.DeleteEgressOnlyInternetGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteEgressOnlyInternetGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteEgressOnlyInternetGatewayInput, ...func(*ec2.Options)) *ec2.DeleteEgressOnlyInternetGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteEgressOnlyInternetGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteEgressOnlyInternetGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteEgressOnlyInternetGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteEgressOnlyInternetGateway'
type EC2_DeleteEgressOnlyInternetGateway_Call struct {
	*mock.Call
}

// DeleteEgressOnlyInternetGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteEgressOnlyInternetGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteEgressOnlyInternetGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteEgressOnlyInternetGateway_Call {
	return &EC2_DeleteEgressOnlyInternetGateway_Call{Call: _e.mock.On("DeleteEgressOnlyInternetGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteEgressOnlyInternetGateway_Call) Run(run func(ctx context.Context, params *ec2.DeleteEgressOnlyInternetGatewayInput, optFns ...func(*ec2.Options))) *EC2_DeleteEgressOnlyInternetGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteEgressOnlyInternetGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteEgressOnlyInternetGateway_Call) Return(_a0 *ec2.DeleteEgressOnlyInternetGatewayOutput, _a1 error) *EC2_DeleteEgressOnlyInternetGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteEgressOnlyInternetGateway_Call) RunAndReturn(run func(context.Context, *ec2.DeleteEgressOnlyInternetGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error)) *EC2_DeleteEgressOnlyInternetGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFleets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteFleets(ctx context.Context, params *ec2.DeleteFleetsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteFleetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteFleets")
	}

	var r0 *ec2.DeleteFleetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFleetsInput, ...func(*ec2.Options)) (*ec2.DeleteFleetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFleetsInput, ...func(*ec2.Options)) *ec2.DeleteFleetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFleetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteFleetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteFleets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFleets'
type EC2_DeleteFleets_Call struct {
	*mock.Call
}

// DeleteFleets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteFleetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteFleets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteFleets_Call {
	return &EC2_DeleteFleets_Call{Call: _e.mock.On("DeleteFleets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteFleets_Call) Run(run func(ctx context.Context, params *ec2.DeleteFleetsInput, optFns ...func(*ec2.Options))) *EC2_DeleteFleets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteFleetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteFleets_Call) Return(_a0 *ec2.DeleteFleetsOutput, _a1 error) *EC2_DeleteFleets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteFleets_Call) RunAndReturn(run func(context.Context, *ec2.DeleteFleetsInput, ...func(*ec2.Options)) (*ec2.DeleteFleetsOutput, error)) *EC2_DeleteFleets_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFlowLogs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteFlowLogs(ctx context.Context, params *ec2.DeleteFlowLogsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteFlowLogsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteFlowLogs")
	}

	var r0 *ec2.DeleteFlowLogsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFlowLogsInput, ...func(*ec2.Options)) (*ec2.DeleteFlowLogsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFlowLogsInput, ...func(*ec2.Options)) *ec2.DeleteFlowLogsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFlowLogsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteFlowLogsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteFlowLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFlowLogs'
type EC2_DeleteFlowLogs_Call struct {
	*mock.Call
}

// DeleteFlowLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteFlowLogsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteFlowLogs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteFlowLogs_Call {
	return &EC2_DeleteFlowLogs_Call{Call: _e.mock.On("DeleteFlowLogs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteFlowLogs_Call) Run(run func(ctx context.Context, params *ec2.DeleteFlowLogsInput, optFns ...func(*ec2.Options))) *EC2_DeleteFlowLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteFlowLogsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteFlowLogs_Call) Return(_a0 *ec2.DeleteFlowLogsOutput, _a1 error) *EC2_DeleteFlowLogs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteFlowLogs_Call) RunAndReturn(run func(context.Context, *ec2.DeleteFlowLogsInput, ...func(*ec2.Options)) (*ec2.DeleteFlowLogsOutput, error)) *EC2_DeleteFlowLogs_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFpgaImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteFpgaImage(ctx context.Context, params *ec2.DeleteFpgaImageInput, optFns ...func(*ec2.Options)) (*ec2.DeleteFpgaImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteFpgaImage")
	}

	var r0 *ec2.DeleteFpgaImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFpgaImageInput, ...func(*ec2.Options)) (*ec2.DeleteFpgaImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteFpgaImageInput, ...func(*ec2.Options)) *ec2.DeleteFpgaImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteFpgaImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteFpgaImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteFpgaImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFpgaImage'
type EC2_DeleteFpgaImage_Call struct {
	*mock.Call
}

// DeleteFpgaImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteFpgaImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteFpgaImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteFpgaImage_Call {
	return &EC2_DeleteFpgaImage_Call{Call: _e.mock.On("DeleteFpgaImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteFpgaImage_Call) Run(run func(ctx context.Context, params *ec2.DeleteFpgaImageInput, optFns ...func(*ec2.Options))) *EC2_DeleteFpgaImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteFpgaImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteFpgaImage_Call) Return(_a0 *ec2.DeleteFpgaImageOutput, _a1 error) *EC2_DeleteFpgaImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteFpgaImage_Call) RunAndReturn(run func(context.Context, *ec2.DeleteFpgaImageInput, ...func(*ec2.Options)) (*ec2.DeleteFpgaImageOutput, error)) *EC2_DeleteFpgaImage_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteImageUsageReport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteImageUsageReport(ctx context.Context, params *ec2.DeleteImageUsageReportInput, optFns ...func(*ec2.Options)) (*ec2.DeleteImageUsageReportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteImageUsageReport")
	}

	var r0 *ec2.DeleteImageUsageReportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteImageUsageReportInput, ...func(*ec2.Options)) (*ec2.DeleteImageUsageReportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteImageUsageReportInput, ...func(*ec2.Options)) *ec2.DeleteImageUsageReportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteImageUsageReportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteImageUsageReportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteImageUsageReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteImageUsageReport'
type EC2_DeleteImageUsageReport_Call struct {
	*mock.Call
}

// DeleteImageUsageReport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteImageUsageReportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteImageUsageReport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteImageUsageReport_Call {
	return &EC2_DeleteImageUsageReport_Call{Call: _e.mock.On("DeleteImageUsageReport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteImageUsageReport_Call) Run(run func(ctx context.Context, params *ec2.DeleteImageUsageReportInput, optFns ...func(*ec2.Options))) *EC2_DeleteImageUsageReport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteImageUsageReportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteImageUsageReport_Call) Return(_a0 *ec2.DeleteImageUsageReportOutput, _a1 error) *EC2_DeleteImageUsageReport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteImageUsageReport_Call) RunAndReturn(run func(context.Context, *ec2.DeleteImageUsageReportInput, ...func(*ec2.Options)) (*ec2.DeleteImageUsageReportOutput, error)) *EC2_DeleteImageUsageReport_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteInstanceConnectEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteInstanceConnectEndpoint(ctx context.Context, params *ec2.DeleteInstanceConnectEndpointInput, optFns ...func(*ec2.Options)) (*ec2.DeleteInstanceConnectEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteInstanceConnectEndpoint")
	}

	var r0 *ec2.DeleteInstanceConnectEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteInstanceConnectEndpointInput, ...func(*ec2.Options)) (*ec2.DeleteInstanceConnectEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteInstanceConnectEndpointInput, ...func(*ec2.Options)) *ec2.DeleteInstanceConnectEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteInstanceConnectEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteInstanceConnectEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteInstanceConnectEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInstanceConnectEndpoint'
type EC2_DeleteInstanceConnectEndpoint_Call struct {
	*mock.Call
}

// DeleteInstanceConnectEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteInstanceConnectEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteInstanceConnectEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteInstanceConnectEndpoint_Call {
	return &EC2_DeleteInstanceConnectEndpoint_Call{Call: _e.mock.On("DeleteInstanceConnectEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteInstanceConnectEndpoint_Call) Run(run func(ctx context.Context, params *ec2.DeleteInstanceConnectEndpointInput, optFns ...func(*ec2.Options))) *EC2_DeleteInstanceConnectEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteInstanceConnectEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteInstanceConnectEndpoint_Call) Return(_a0 *ec2.DeleteInstanceConnectEndpointOutput, _a1 error) *EC2_DeleteInstanceConnectEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteInstanceConnectEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.DeleteInstanceConnectEndpointInput, ...func(*ec2.Options)) (*ec2.DeleteInstanceConnectEndpointOutput, error)) *EC2_DeleteInstanceConnectEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteInstanceEventWindow provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteInstanceEventWindow(ctx context.Context, params *ec2.DeleteInstanceEventWindowInput, optFns ...func(*ec2.Options)) (*ec2.DeleteInstanceEventWindowOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteInstanceEventWindow")
	}

	var r0 *ec2.DeleteInstanceEventWindowOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.DeleteInstanceEventWindowOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteInstanceEventWindowInput, ...func(*ec2.Options)) *ec2.DeleteInstanceEventWindowOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteInstanceEventWindowOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteInstanceEventWindowInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteInstanceEventWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInstanceEventWindow'
type EC2_DeleteInstanceEventWindow_Call struct {
	*mock.Call
}

// DeleteInstanceEventWindow is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteInstanceEventWindowInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteInstanceEventWindow(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteInstanceEventWindow_Call {
	return &EC2_DeleteInstanceEventWindow_Call{Call: _e.mock.On("DeleteInstanceEventWindow",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteInstanceEventWindow_Call) Run(run func(ctx context.Context, params *ec2.DeleteInstanceEventWindowInput, optFns ...func(*ec2.Options))) *EC2_DeleteInstanceEventWindow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteInstanceEventWindowInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteInstanceEventWindow_Call) Return(_a0 *ec2.DeleteInstanceEventWindowOutput, _a1 error) *EC2_DeleteInstanceEventWindow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteInstanceEventWindow_Call) RunAndReturn(run func(context.Context, *ec2.DeleteInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.DeleteInstanceEventWindowOutput, error)) *EC2_DeleteInstanceEventWindow_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteInternetGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteInternetGateway(ctx context.Context, params *ec2.DeleteInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteInternetGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteInternetGateway")
	}

	var r0 *ec2.DeleteInternetGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteInternetGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteInternetGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteInternetGatewayInput, ...func(*ec2.Options)) *ec2.DeleteInternetGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteInternetGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteInternetGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteInternetGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInternetGateway'
type EC2_DeleteInternetGateway_Call struct {
	*mock.Call
}

// DeleteInternetGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteInternetGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteInternetGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteInternetGateway_Call {
	return &EC2_DeleteInternetGateway_Call{Call: _e.mock.On("DeleteInternetGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteInternetGateway_Call) Run(run func(ctx context.Context, params *ec2.DeleteInternetGatewayInput, optFns ...func(*ec2.Options))) *EC2_DeleteInternetGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteInternetGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteInternetGateway_Call) Return(_a0 *ec2.DeleteInternetGatewayOutput, _a1 error) *EC2_DeleteInternetGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteInternetGateway_Call) RunAndReturn(run func(context.Context, *ec2.DeleteInternetGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteInternetGatewayOutput, error)) *EC2_DeleteInternetGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIpam provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteIpam(ctx context.Context, params *ec2.DeleteIpamInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteIpam")
	}

	var r0 *ec2.DeleteIpamOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamInput, ...func(*ec2.Options)) (*ec2.DeleteIpamOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamInput, ...func(*ec2.Options)) *ec2.DeleteIpamOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteIpamOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteIpam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpam'
type EC2_DeleteIpam_Call struct {
	*mock.Call
}

// DeleteIpam is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteIpamInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteIpam(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpam_Call {
	return &EC2_DeleteIpam_Call{Call: _e.mock.On("DeleteIpam",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteIpam_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteIpamInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteIpam_Call) Return(_a0 *ec2.DeleteIpamOutput, _a1 error) *EC2_DeleteIpam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteIpam_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamInput, ...func(*ec2.Options)) (*ec2.DeleteIpamOutput, error)) *EC2_DeleteIpam_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIpamExternalResourceVerificationToken provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteIpamExternalResourceVerificationToken(ctx context.Context, params *ec2.DeleteIpamExternalResourceVerificationTokenInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamExternalResourceVerificationTokenOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteIpamExternalResourceVerificationToken")
	}

	var r0 *ec2.DeleteIpamExternalResourceVerificationTokenOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamExternalResourceVerificationTokenInput, ...func(*ec2.Options)) (*ec2.DeleteIpamExternalResourceVerificationTokenOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamExternalResourceVerificationTokenInput, ...func(*ec2.Options)) *ec2.DeleteIpamExternalResourceVerificationTokenOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteIpamExternalResourceVerificationTokenOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamExternalResourceVerificationTokenInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteIpamExternalResourceVerificationToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpamExternalResourceVerificationToken'
type EC2_DeleteIpamExternalResourceVerificationToken_Call struct {
	*mock.Call
}

// DeleteIpamExternalResourceVerificationToken is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteIpamExternalResourceVerificationTokenInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteIpamExternalResourceVerificationToken(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpamExternalResourceVerificationToken_Call {
	return &EC2_DeleteIpamExternalResourceVerificationToken_Call{Call: _e.mock.On("DeleteIpamExternalResourceVerificationToken",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteIpamExternalResourceVerificationToken_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamExternalResourceVerificationTokenInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpamExternalResourceVerificationToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteIpamExternalResourceVerificationTokenInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteIpamExternalResourceVerificationToken_Call) Return(_a0 *ec2.DeleteIpamExternalResourceVerificationTokenOutput, _a1 error) *EC2_DeleteIpamExternalResourceVerificationToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteIpamExternalResourceVerificationToken_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamExternalResourceVerificationTokenInput, ...func(*ec2.Options)) (*ec2.DeleteIpamExternalResourceVerificationTokenOutput, error)) *EC2_DeleteIpamExternalResourceVerificationToken_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIpamPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteIpamPolicy(ctx context.Context, params *ec2.DeleteIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteIpamPolicy")
	}

	var r0 *ec2.DeleteIpamPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPolicyInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPolicyInput, ...func(*ec2.Options)) *ec2.DeleteIpamPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteIpamPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpamPolicy'
type EC2_DeleteIpamPolicy_Call struct {
	*mock.Call
}

// DeleteIpamPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteIpamPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpamPolicy_Call {
	return &EC2_DeleteIpamPolicy_Call{Call: _e.mock.On("DeleteIpamPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpamPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteIpamPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteIpamPolicy_Call) Return(_a0 *ec2.DeleteIpamPolicyOutput, _a1 error) *EC2_DeleteIpamPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamPolicyInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPolicyOutput, error)) *EC2_DeleteIpamPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIpamPool provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteIpamPool(ctx context.Context, params *ec2.DeleteIpamPoolInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamPoolOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteIpamPool")
	}

	var r0 *ec2.DeleteIpamPoolOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPoolInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPoolOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPoolInput, ...func(*ec2.Options)) *ec2.DeleteIpamPoolOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteIpamPoolOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamPoolInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteIpamPool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpamPool'
type EC2_DeleteIpamPool_Call struct {
	*mock.Call
}

// DeleteIpamPool is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteIpamPoolInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteIpamPool(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpamPool_Call {
	return &EC2_DeleteIpamPool_Call{Call: _e.mock.On("DeleteIpamPool",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteIpamPool_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamPoolInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpamPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteIpamPoolInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteIpamPool_Call) Return(_a0 *ec2.DeleteIpamPoolOutput, _a1 error) *EC2_DeleteIpamPool_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteIpamPool_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamPoolInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPoolOutput, error)) *EC2_DeleteIpamPool_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIpamPrefixListResolver provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteIpamPrefixListResolver(ctx context.Context, params *ec2.DeleteIpamPrefixListResolverInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamPrefixListResolverOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteIpamPrefixListResolver")
	}

	var r0 *ec2.DeleteIpamPrefixListResolverOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPrefixListResolverInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPrefixListResolverOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPrefixListResolverInput, ...func(*ec2.Options)) *ec2.DeleteIpamPrefixListResolverOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteIpamPrefixListResolverOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamPrefixListResolverInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteIpamPrefixListResolver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpamPrefixListResolver'
type EC2_DeleteIpamPrefixListResolver_Call struct {
	*mock.Call
}

// DeleteIpamPrefixListResolver is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteIpamPrefixListResolverInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteIpamPrefixListResolver(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpamPrefixListResolver_Call {
	return &EC2_DeleteIpamPrefixListResolver_Call{Call: _e.mock.On("DeleteIpamPrefixListResolver",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteIpamPrefixListResolver_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamPrefixListResolverInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpamPrefixListResolver_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteIpamPrefixListResolverInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteIpamPrefixListResolver_Call) Return(_a0 *ec2.DeleteIpamPrefixListResolverOutput, _a1 error) *EC2_DeleteIpamPrefixListResolver_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteIpamPrefixListResolver_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamPrefixListResolverInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPrefixListResolverOutput, error)) *EC2_DeleteIpamPrefixListResolver_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIpamPrefixListResolverTarget provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteIpamPrefixListResolverTarget(ctx context.Context, params *ec2.DeleteIpamPrefixListResolverTargetInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamPrefixListResolverTargetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteIpamPrefixListResolverTarget")
	}

	var r0 *ec2.DeleteIpamPrefixListResolverTargetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPrefixListResolverTargetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) *ec2.DeleteIpamPrefixListResolverTargetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteIpamPrefixListResolverTargetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteIpamPrefixListResolverTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpamPrefixListResolverTarget'
type EC2_DeleteIpamPrefixListResolverTarget_Call struct {
	*mock.Call
}

// DeleteIpamPrefixListResolverTarget is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteIpamPrefixListResolverTargetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteIpamPrefixListResolverTarget(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpamPrefixListResolverTarget_Call {
	return &EC2_DeleteIpamPrefixListResolverTarget_Call{Call: _e.mock.On("DeleteIpamPrefixListResolverTarget",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteIpamPrefixListResolverTarget_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamPrefixListResolverTargetInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpamPrefixListResolverTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteIpamPrefixListResolverTargetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteIpamPrefixListResolverTarget_Call) Return(_a0 *ec2.DeleteIpamPrefixListResolverTargetOutput, _a1 error) *EC2_DeleteIpamPrefixListResolverTarget_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteIpamPrefixListResolverTarget_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) (*ec2.DeleteIpamPrefixListResolverTargetOutput, error)) *EC2_DeleteIpamPrefixListResolverTarget_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIpamResourceDiscovery provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteIpamResourceDiscovery(ctx context.Context, params *ec2.DeleteIpamResourceDiscoveryInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamResourceDiscoveryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteIpamResourceDiscovery")
	}

	var r0 *ec2.DeleteIpamResourceDiscoveryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.DeleteIpamResourceDiscoveryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamResourceDiscoveryInput, ...func(*ec2.Options)) *ec2.DeleteIpamResourceDiscoveryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteIpamResourceDiscoveryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamResourceDiscoveryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteIpamResourceDiscovery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpamResourceDiscovery'
type EC2_DeleteIpamResourceDiscovery_Call struct {
	*mock.Call
}

// DeleteIpamResourceDiscovery is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteIpamResourceDiscoveryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteIpamResourceDiscovery(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpamResourceDiscovery_Call {
	return &EC2_DeleteIpamResourceDiscovery_Call{Call: _e.mock.On("DeleteIpamResourceDiscovery",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteIpamResourceDiscovery_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamResourceDiscoveryInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpamResourceDiscovery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteIpamResourceDiscoveryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteIpamResourceDiscovery_Call) Return(_a0 *ec2.DeleteIpamResourceDiscoveryOutput, _a1 error) *EC2_DeleteIpamResourceDiscovery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteIpamResourceDiscovery_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.DeleteIpamResourceDiscoveryOutput, error)) *EC2_DeleteIpamResourceDiscovery_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIpamScope provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteIpamScope(ctx context.Context, params *ec2.DeleteIpamScopeInput, optFns ...func(*ec2.Options)) (*ec2.DeleteIpamScopeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteIpamScope")
	}

	var r0 *ec2.DeleteIpamScopeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamScopeInput, ...func(*ec2.Options)) (*ec2.DeleteIpamScopeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteIpamScopeInput, ...func(*ec2.Options)) *ec2.DeleteIpamScopeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteIpamScopeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteIpamScopeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteIpamScope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIpamScope'
type EC2_DeleteIpamScope_Call struct {
	*mock.Call
}

// DeleteIpamScope is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteIpamScopeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteIpamScope(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteIpamScope_Call {
	return &EC2_DeleteIpamScope_Call{Call: _e.mock.On("DeleteIpamScope",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteIpamScope_Call) Run(run func(ctx context.Context, params *ec2.DeleteIpamScopeInput, optFns ...func(*ec2.Options))) *EC2_DeleteIpamScope_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteIpamScopeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteIpamScope_Call) Return(_a0 *ec2.DeleteIpamScopeOutput, _a1 error) *EC2_DeleteIpamScope_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteIpamScope_Call) RunAndReturn(run func(context.Context, *ec2.DeleteIpamScopeInput, ...func(*ec2.Options)) (*ec2.DeleteIpamScopeOutput, error)) *EC2_DeleteIpamScope_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteKeyPair provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteKeyPair(ctx context.Context, params *ec2.DeleteKeyPairInput, optFns ...func(*ec2.Options)) (*ec2.DeleteKeyPairOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteKeyPair")
	}

	var r0 *ec2.DeleteKeyPairOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteKeyPairInput, ...func(*ec2.Options)) (*ec2.DeleteKeyPairOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteKeyPairInput, ...func(*ec2.Options)) *ec2.DeleteKeyPairOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteKeyPairOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteKeyPairInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteKeyPair_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteKeyPair'
type EC2_DeleteKeyPair_Call struct {
	*mock.Call
}

// DeleteKeyPair is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteKeyPairInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteKeyPair(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteKeyPair_Call {
	return &EC2_DeleteKeyPair_Call{Call: _e.mock.On("DeleteKeyPair",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteKeyPair_Call) Run(run func(ctx context.Context, params *ec2.DeleteKeyPairInput, optFns ...func(*ec2.Options))) *EC2_DeleteKeyPair_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteKeyPairInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteKeyPair_Call) Return(_a0 *ec2.DeleteKeyPairOutput, _a1 error) *EC2_DeleteKeyPair_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteKeyPair_Call) RunAndReturn(run func(context.Context, *ec2.DeleteKeyPairInput, ...func(*ec2.Options)) (*ec2.DeleteKeyPairOutput, error)) *EC2_DeleteKeyPair_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLaunchTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteLaunchTemplate(ctx context.Context, params *ec2.DeleteLaunchTemplateInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLaunchTemplate")
	}

	var r0 *ec2.DeleteLaunchTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLaunchTemplateInput, ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLaunchTemplateInput, ...func(*ec2.Options)) *ec2.DeleteLaunchTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLaunchTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteLaunchTemplateInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteLaunchTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLaunchTemplate'
type EC2_DeleteLaunchTemplate_Call struct {
	*mock.Call
}

// DeleteLaunchTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteLaunchTemplateInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteLaunchTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteLaunchTemplate_Call {
	return &EC2_DeleteLaunchTemplate_Call{Call: _e.mock.On("DeleteLaunchTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteLaunchTemplate_Call) Run(run func(ctx context.Context, params *ec2.DeleteLaunchTemplateInput, optFns ...func(*ec2.Options))) *EC2_DeleteLaunchTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteLaunchTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteLaunchTemplate_Call) Return(_a0 *ec2.DeleteLaunchTemplateOutput, _a1 error) *EC2_DeleteLaunchTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteLaunchTemplate_Call) RunAndReturn(run func(context.Context, *ec2.DeleteLaunchTemplateInput, ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateOutput, error)) *EC2_DeleteLaunchTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLaunchTemplateVersions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteLaunchTemplateVersions(ctx context.Context, params *ec2.DeleteLaunchTemplateVersionsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateVersionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLaunchTemplateVersions")
	}

	var r0 *ec2.DeleteLaunchTemplateVersionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLaunchTemplateVersionsInput, ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateVersionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLaunchTemplateVersionsInput, ...func(*ec2.Options)) *ec2.DeleteLaunchTemplateVersionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLaunchTemplateVersionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteLaunchTemplateVersionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteLaunchTemplateVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLaunchTemplateVersions'
type EC2_DeleteLaunchTemplateVersions_Call struct {
	*mock.Call
}

// DeleteLaunchTemplateVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteLaunchTemplateVersionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteLaunchTemplateVersions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteLaunchTemplateVersions_Call {
	return &EC2_DeleteLaunchTemplateVersions_Call{Call: _e.mock.On("DeleteLaunchTemplateVersions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteLaunchTemplateVersions_Call) Run(run func(ctx context.Context, params *ec2.DeleteLaunchTemplateVersionsInput, optFns ...func(*ec2.Options))) *EC2_DeleteLaunchTemplateVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteLaunchTemplateVersionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteLaunchTemplateVersions_Call) Return(_a0 *ec2.DeleteLaunchTemplateVersionsOutput, _a1 error) *EC2_DeleteLaunchTemplateVersions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteLaunchTemplateVersions_Call) RunAndReturn(run func(context.Context, *ec2.DeleteLaunchTemplateVersionsInput, ...func(*ec2.Options)) (*ec2.DeleteLaunchTemplateVersionsOutput, error)) *EC2_DeleteLaunchTemplateVersions_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLocalGatewayRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteLocalGatewayRoute(ctx context.Context, params *ec2.DeleteLocalGatewayRouteInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLocalGatewayRoute")
	}

	var r0 *ec2.DeleteLocalGatewayRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteInput, ...func(*ec2.Options)) *ec2.DeleteLocalGatewayRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteLocalGatewayRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteLocalGatewayRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLocalGatewayRoute'
type EC2_DeleteLocalGatewayRoute_Call struct {
	*mock.Call
}

// DeleteLocalGatewayRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteLocalGatewayRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteLocalGatewayRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteLocalGatewayRoute_Call {
	return &EC2_DeleteLocalGatewayRoute_Call{Call: _e.mock.On("DeleteLocalGatewayRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteLocalGatewayRoute_Call) Run(run func(ctx context.Context, params *ec2.DeleteLocalGatewayRouteInput, optFns ...func(*ec2.Options))) *EC2_DeleteLocalGatewayRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteLocalGatewayRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteLocalGatewayRoute_Call) Return(_a0 *ec2.DeleteLocalGatewayRouteOutput, _a1 error) *EC2_DeleteLocalGatewayRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteLocalGatewayRoute_Call) RunAndReturn(run func(context.Context, *ec2.DeleteLocalGatewayRouteInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteOutput, error)) *EC2_DeleteLocalGatewayRoute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLocalGatewayRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteLocalGatewayRouteTable(ctx context.Context, params *ec2.DeleteLocalGatewayRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLocalGatewayRouteTable")
	}

	var r0 *ec2.DeleteLocalGatewayRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableInput, ...func(*ec2.Options)) *ec2.DeleteLocalGatewayRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteLocalGatewayRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLocalGatewayRouteTable'
type EC2_DeleteLocalGatewayRouteTable_Call struct {
	*mock.Call
}

// DeleteLocalGatewayRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteLocalGatewayRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteLocalGatewayRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteLocalGatewayRouteTable_Call {
	return &EC2_DeleteLocalGatewayRouteTable_Call{Call: _e.mock.On("DeleteLocalGatewayRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteLocalGatewayRouteTable_Call) Run(run func(ctx context.Context, params *ec2.DeleteLocalGatewayRouteTableInput, optFns ...func(*ec2.Options))) *EC2_DeleteLocalGatewayRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteLocalGatewayRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteLocalGatewayRouteTable_Call) Return(_a0 *ec2.DeleteLocalGatewayRouteTableOutput, _a1 error) *EC2_DeleteLocalGatewayRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteLocalGatewayRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.DeleteLocalGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableOutput, error)) *EC2_DeleteLocalGatewayRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(ctx context.Context, params *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation")
	}

	var r0 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, ...func(*ec2.Options)) *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation'
type EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call struct {
	*mock.Call
}

// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call {
	return &EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call{Call: _e.mock.On("DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call) Run(run func(ctx context.Context, params *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, optFns ...func(*ec2.Options))) *EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call) Return(_a0 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, _a1 error) *EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call) RunAndReturn(run func(context.Context, *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error)) *EC2_DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLocalGatewayRouteTableVpcAssociation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteLocalGatewayRouteTableVpcAssociation(ctx context.Context, params *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLocalGatewayRouteTableVpcAssociation")
	}

	var r0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, ...func(*ec2.Options)) *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLocalGatewayRouteTableVpcAssociation'
type EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call struct {
	*mock.Call
}

// DeleteLocalGatewayRouteTableVpcAssociation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteLocalGatewayRouteTableVpcAssociation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call {
	return &EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call{Call: _e.mock.On("DeleteLocalGatewayRouteTableVpcAssociation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call) Run(run func(ctx context.Context, params *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, optFns ...func(*ec2.Options))) *EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call) Return(_a0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, _a1 error) *EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call) RunAndReturn(run func(context.Context, *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error)) *EC2_DeleteLocalGatewayRouteTableVpcAssociation_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLocalGatewayVirtualInterface provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteLocalGatewayVirtualInterface(ctx context.Context, params *ec2.DeleteLocalGatewayVirtualInterfaceInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayVirtualInterfaceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLocalGatewayVirtualInterface")
	}

	var r0 *ec2.DeleteLocalGatewayVirtualInterfaceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayVirtualInterfaceInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayVirtualInterfaceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayVirtualInterfaceInput, ...func(*ec2.Options)) *ec2.DeleteLocalGatewayVirtualInterfaceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayVirtualInterfaceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteLocalGatewayVirtualInterfaceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteLocalGatewayVirtualInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLocalGatewayVirtualInterface'
type EC2_DeleteLocalGatewayVirtualInterface_Call struct {
	*mock.Call
}

// DeleteLocalGatewayVirtualInterface is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteLocalGatewayVirtualInterfaceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteLocalGatewayVirtualInterface(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteLocalGatewayVirtualInterface_Call {
	return &EC2_DeleteLocalGatewayVirtualInterface_Call{Call: _e.mock.On("DeleteLocalGatewayVirtualInterface",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteLocalGatewayVirtualInterface_Call) Run(run func(ctx context.Context, params *ec2.DeleteLocalGatewayVirtualInterfaceInput, optFns ...func(*ec2.Options))) *EC2_DeleteLocalGatewayVirtualInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteLocalGatewayVirtualInterfaceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteLocalGatewayVirtualInterface_Call) Return(_a0 *ec2.DeleteLocalGatewayVirtualInterfaceOutput, _a1 error) *EC2_DeleteLocalGatewayVirtualInterface_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteLocalGatewayVirtualInterface_Call) RunAndReturn(run func(context.Context, *ec2.DeleteLocalGatewayVirtualInterfaceInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayVirtualInterfaceOutput, error)) *EC2_DeleteLocalGatewayVirtualInterface_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLocalGatewayVirtualInterfaceGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteLocalGatewayVirtualInterfaceGroup(ctx context.Context, params *ec2.DeleteLocalGatewayVirtualInterfaceGroupInput, optFns ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayVirtualInterfaceGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLocalGatewayVirtualInterfaceGroup")
	}

	var r0 *ec2.DeleteLocalGatewayVirtualInterfaceGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayVirtualInterfaceGroupInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayVirtualInterfaceGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteLocalGatewayVirtualInterfaceGroupInput, ...func(*ec2.Options)) *ec2.DeleteLocalGatewayVirtualInterfaceGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteLocalGatewayVirtualInterfaceGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteLocalGatewayVirtualInterfaceGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLocalGatewayVirtualInterfaceGroup'
type EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call struct {
	*mock.Call
}

// DeleteLocalGatewayVirtualInterfaceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteLocalGatewayVirtualInterfaceGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteLocalGatewayVirtualInterfaceGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call {
	return &EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call{Call: _e.mock.On("DeleteLocalGatewayVirtualInterfaceGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call) Run(run func(ctx context.Context, params *ec2.DeleteLocalGatewayVirtualInterfaceGroupInput, optFns ...func(*ec2.Options))) *EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteLocalGatewayVirtualInterfaceGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call) Return(_a0 *ec2.DeleteLocalGatewayVirtualInterfaceGroupOutput, _a1 error) *EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call) RunAndReturn(run func(context.Context, *ec2.DeleteLocalGatewayVirtualInterfaceGroupInput, ...func(*ec2.Options)) (*ec2.DeleteLocalGatewayVirtualInterfaceGroupOutput, error)) *EC2_DeleteLocalGatewayVirtualInterfaceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteManagedPrefixList provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteManagedPrefixList(ctx context.Context, params *ec2.DeleteManagedPrefixListInput, optFns ...func(*ec2.Options)) (*ec2.DeleteManagedPrefixListOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteManagedPrefixList")
	}

	var r0 *ec2.DeleteManagedPrefixListOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteManagedPrefixListInput, ...func(*ec2.Options)) (*ec2.DeleteManagedPrefixListOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteManagedPrefixListInput, ...func(*ec2.Options)) *ec2.DeleteManagedPrefixListOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteManagedPrefixListOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteManagedPrefixListInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteManagedPrefixList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteManagedPrefixList'
type EC2_DeleteManagedPrefixList_Call struct {
	*mock.Call
}

// DeleteManagedPrefixList is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteManagedPrefixListInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteManagedPrefixList(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteManagedPrefixList_Call {
	return &EC2_DeleteManagedPrefixList_Call{Call: _e.mock.On("DeleteManagedPrefixList",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteManagedPrefixList_Call) Run(run func(ctx context.Context, params *ec2.DeleteManagedPrefixListInput, optFns ...func(*ec2.Options))) *EC2_DeleteManagedPrefixList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteManagedPrefixListInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteManagedPrefixList_Call) Return(_a0 *ec2.DeleteManagedPrefixListOutput, _a1 error) *EC2_DeleteManagedPrefixList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteManagedPrefixList_Call) RunAndReturn(run func(context.Context, *ec2.DeleteManagedPrefixListInput, ...func(*ec2.Options)) (*ec2.DeleteManagedPrefixListOutput, error)) *EC2_DeleteManagedPrefixList_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNatGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNatGateway(ctx context.Context, params *ec2.DeleteNatGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNatGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNatGateway")
	}

	var r0 *ec2.DeleteNatGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNatGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteNatGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNatGatewayInput, ...func(*ec2.Options)) *ec2.DeleteNatGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNatGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNatGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNatGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNatGateway'
type EC2_DeleteNatGateway_Call struct {
	*mock.Call
}

// DeleteNatGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNatGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNatGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNatGateway_Call {
	return &EC2_DeleteNatGateway_Call{Call: _e.mock.On("DeleteNatGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNatGateway_Call) Run(run func(ctx context.Context, params *ec2.DeleteNatGatewayInput, optFns ...func(*ec2.Options))) *EC2_DeleteNatGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNatGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNatGateway_Call) Return(_a0 *ec2.DeleteNatGatewayOutput, _a1 error) *EC2_DeleteNatGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNatGateway_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNatGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteNatGatewayOutput, error)) *EC2_DeleteNatGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNetworkAcl provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNetworkAcl(ctx context.Context, params *ec2.DeleteNetworkAclInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNetworkAclOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNetworkAcl")
	}

	var r0 *ec2.DeleteNetworkAclOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkAclInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkAclOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkAclInput, ...func(*ec2.Options)) *ec2.DeleteNetworkAclOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkAclOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNetworkAclInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNetworkAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNetworkAcl'
type EC2_DeleteNetworkAcl_Call struct {
	*mock.Call
}

// DeleteNetworkAcl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNetworkAclInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNetworkAcl(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNetworkAcl_Call {
	return &EC2_DeleteNetworkAcl_Call{Call: _e.mock.On("DeleteNetworkAcl",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNetworkAcl_Call) Run(run func(ctx context.Context, params *ec2.DeleteNetworkAclInput, optFns ...func(*ec2.Options))) *EC2_DeleteNetworkAcl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNetworkAclInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNetworkAcl_Call) Return(_a0 *ec2.DeleteNetworkAclOutput, _a1 error) *EC2_DeleteNetworkAcl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNetworkAcl_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNetworkAclInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkAclOutput, error)) *EC2_DeleteNetworkAcl_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNetworkAclEntry provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNetworkAclEntry(ctx context.Context, params *ec2.DeleteNetworkAclEntryInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNetworkAclEntryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNetworkAclEntry")
	}

	var r0 *ec2.DeleteNetworkAclEntryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkAclEntryInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkAclEntryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkAclEntryInput, ...func(*ec2.Options)) *ec2.DeleteNetworkAclEntryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkAclEntryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNetworkAclEntryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNetworkAclEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNetworkAclEntry'
type EC2_DeleteNetworkAclEntry_Call struct {
	*mock.Call
}

// DeleteNetworkAclEntry is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNetworkAclEntryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNetworkAclEntry(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNetworkAclEntry_Call {
	return &EC2_DeleteNetworkAclEntry_Call{Call: _e.mock.On("DeleteNetworkAclEntry",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNetworkAclEntry_Call) Run(run func(ctx context.Context, params *ec2.DeleteNetworkAclEntryInput, optFns ...func(*ec2.Options))) *EC2_DeleteNetworkAclEntry_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNetworkAclEntryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNetworkAclEntry_Call) Return(_a0 *ec2.DeleteNetworkAclEntryOutput, _a1 error) *EC2_DeleteNetworkAclEntry_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNetworkAclEntry_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNetworkAclEntryInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkAclEntryOutput, error)) *EC2_DeleteNetworkAclEntry_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNetworkInsightsAccessScope provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNetworkInsightsAccessScope(ctx context.Context, params *ec2.DeleteNetworkInsightsAccessScopeInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNetworkInsightsAccessScope")
	}

	var r0 *ec2.DeleteNetworkInsightsAccessScopeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsAccessScopeInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsAccessScopeInput, ...func(*ec2.Options)) *ec2.DeleteNetworkInsightsAccessScopeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInsightsAccessScopeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNetworkInsightsAccessScopeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNetworkInsightsAccessScope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNetworkInsightsAccessScope'
type EC2_DeleteNetworkInsightsAccessScope_Call struct {
	*mock.Call
}

// DeleteNetworkInsightsAccessScope is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNetworkInsightsAccessScopeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNetworkInsightsAccessScope(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNetworkInsightsAccessScope_Call {
	return &EC2_DeleteNetworkInsightsAccessScope_Call{Call: _e.mock.On("DeleteNetworkInsightsAccessScope",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNetworkInsightsAccessScope_Call) Run(run func(ctx context.Context, params *ec2.DeleteNetworkInsightsAccessScopeInput, optFns ...func(*ec2.Options))) *EC2_DeleteNetworkInsightsAccessScope_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNetworkInsightsAccessScopeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNetworkInsightsAccessScope_Call) Return(_a0 *ec2.DeleteNetworkInsightsAccessScopeOutput, _a1 error) *EC2_DeleteNetworkInsightsAccessScope_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNetworkInsightsAccessScope_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNetworkInsightsAccessScopeInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error)) *EC2_DeleteNetworkInsightsAccessScope_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNetworkInsightsAccessScopeAnalysis provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNetworkInsightsAccessScopeAnalysis(ctx context.Context, params *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNetworkInsightsAccessScopeAnalysis")
	}

	var r0 *ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, ...func(*ec2.Options)) *ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNetworkInsightsAccessScopeAnalysis'
type EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call struct {
	*mock.Call
}

// DeleteNetworkInsightsAccessScopeAnalysis is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNetworkInsightsAccessScopeAnalysis(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call {
	return &EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call{Call: _e.mock.On("DeleteNetworkInsightsAccessScopeAnalysis",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call) Run(run func(ctx context.Context, params *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, optFns ...func(*ec2.Options))) *EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call) Return(_a0 *ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, _a1 error) *EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error)) *EC2_DeleteNetworkInsightsAccessScopeAnalysis_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNetworkInsightsAnalysis provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNetworkInsightsAnalysis(ctx context.Context, params *ec2.DeleteNetworkInsightsAnalysisInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAnalysisOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNetworkInsightsAnalysis")
	}

	var r0 *ec2.DeleteNetworkInsightsAnalysisOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsAnalysisInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAnalysisOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsAnalysisInput, ...func(*ec2.Options)) *ec2.DeleteNetworkInsightsAnalysisOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInsightsAnalysisOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNetworkInsightsAnalysisInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNetworkInsightsAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNetworkInsightsAnalysis'
type EC2_DeleteNetworkInsightsAnalysis_Call struct {
	*mock.Call
}

// DeleteNetworkInsightsAnalysis is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNetworkInsightsAnalysisInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNetworkInsightsAnalysis(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNetworkInsightsAnalysis_Call {
	return &EC2_DeleteNetworkInsightsAnalysis_Call{Call: _e.mock.On("DeleteNetworkInsightsAnalysis",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNetworkInsightsAnalysis_Call) Run(run func(ctx context.Context, params *ec2.DeleteNetworkInsightsAnalysisInput, optFns ...func(*ec2.Options))) *EC2_DeleteNetworkInsightsAnalysis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNetworkInsightsAnalysisInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNetworkInsightsAnalysis_Call) Return(_a0 *ec2.DeleteNetworkInsightsAnalysisOutput, _a1 error) *EC2_DeleteNetworkInsightsAnalysis_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNetworkInsightsAnalysis_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNetworkInsightsAnalysisInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsAnalysisOutput, error)) *EC2_DeleteNetworkInsightsAnalysis_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNetworkInsightsPath provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNetworkInsightsPath(ctx context.Context, params *ec2.DeleteNetworkInsightsPathInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsPathOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNetworkInsightsPath")
	}

	var r0 *ec2.DeleteNetworkInsightsPathOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsPathInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsPathOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInsightsPathInput, ...func(*ec2.Options)) *ec2.DeleteNetworkInsightsPathOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInsightsPathOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNetworkInsightsPathInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNetworkInsightsPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNetworkInsightsPath'
type EC2_DeleteNetworkInsightsPath_Call struct {
	*mock.Call
}

// DeleteNetworkInsightsPath is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNetworkInsightsPathInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNetworkInsightsPath(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNetworkInsightsPath_Call {
	return &EC2_DeleteNetworkInsightsPath_Call{Call: _e.mock.On("DeleteNetworkInsightsPath",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNetworkInsightsPath_Call) Run(run func(ctx context.Context, params *ec2.DeleteNetworkInsightsPathInput, optFns ...func(*ec2.Options))) *EC2_DeleteNetworkInsightsPath_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNetworkInsightsPathInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNetworkInsightsPath_Call) Return(_a0 *ec2.DeleteNetworkInsightsPathOutput, _a1 error) *EC2_DeleteNetworkInsightsPath_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNetworkInsightsPath_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNetworkInsightsPathInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInsightsPathOutput, error)) *EC2_DeleteNetworkInsightsPath_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNetworkInterface provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNetworkInterface(ctx context.Context, params *ec2.DeleteNetworkInterfaceInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNetworkInterfaceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNetworkInterface")
	}

	var r0 *ec2.DeleteNetworkInterfaceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInterfaceInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInterfaceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInterfaceInput, ...func(*ec2.Options)) *ec2.DeleteNetworkInterfaceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInterfaceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNetworkInterfaceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNetworkInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNetworkInterface'
type EC2_DeleteNetworkInterface_Call struct {
	*mock.Call
}

// DeleteNetworkInterface is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNetworkInterfaceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNetworkInterface(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNetworkInterface_Call {
	return &EC2_DeleteNetworkInterface_Call{Call: _e.mock.On("DeleteNetworkInterface",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNetworkInterface_Call) Run(run func(ctx context.Context, params *ec2.DeleteNetworkInterfaceInput, optFns ...func(*ec2.Options))) *EC2_DeleteNetworkInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNetworkInterfaceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNetworkInterface_Call) Return(_a0 *ec2.DeleteNetworkInterfaceOutput, _a1 error) *EC2_DeleteNetworkInterface_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNetworkInterface_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNetworkInterfaceInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInterfaceOutput, error)) *EC2_DeleteNetworkInterface_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNetworkInterfacePermission provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteNetworkInterfacePermission(ctx context.Context, params *ec2.DeleteNetworkInterfacePermissionInput, optFns ...func(*ec2.Options)) (*ec2.DeleteNetworkInterfacePermissionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteNetworkInterfacePermission")
	}

	var r0 *ec2.DeleteNetworkInterfacePermissionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInterfacePermissionInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInterfacePermissionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteNetworkInterfacePermissionInput, ...func(*ec2.Options)) *ec2.DeleteNetworkInterfacePermissionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteNetworkInterfacePermissionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteNetworkInterfacePermissionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteNetworkInterfacePermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNetworkInterfacePermission'
type EC2_DeleteNetworkInterfacePermission_Call struct {
	*mock.Call
}

// DeleteNetworkInterfacePermission is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteNetworkInterfacePermissionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteNetworkInterfacePermission(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteNetworkInterfacePermission_Call {
	return &EC2_DeleteNetworkInterfacePermission_Call{Call: _e.mock.On("DeleteNetworkInterfacePermission",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteNetworkInterfacePermission_Call) Run(run func(ctx context.Context, params *ec2.DeleteNetworkInterfacePermissionInput, optFns ...func(*ec2.Options))) *EC2_DeleteNetworkInterfacePermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteNetworkInterfacePermissionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteNetworkInterfacePermission_Call) Return(_a0 *ec2.DeleteNetworkInterfacePermissionOutput, _a1 error) *EC2_DeleteNetworkInterfacePermission_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteNetworkInterfacePermission_Call) RunAndReturn(run func(context.Context, *ec2.DeleteNetworkInterfacePermissionInput, ...func(*ec2.Options)) (*ec2.DeleteNetworkInterfacePermissionOutput, error)) *EC2_DeleteNetworkInterfacePermission_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePlacementGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeletePlacementGroup(ctx context.Context, params *ec2.DeletePlacementGroupInput, optFns ...func(*ec2.Options)) (*ec2.DeletePlacementGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeletePlacementGroup")
	}

	var r0 *ec2.DeletePlacementGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeletePlacementGroupInput, ...func(*ec2.Options)) (*ec2.DeletePlacementGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeletePlacementGroupInput, ...func(*ec2.Options)) *ec2.DeletePlacementGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeletePlacementGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeletePlacementGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeletePlacementGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePlacementGroup'
type EC2_DeletePlacementGroup_Call struct {
	*mock.Call
}

// DeletePlacementGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeletePlacementGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeletePlacementGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeletePlacementGroup_Call {
	return &EC2_DeletePlacementGroup_Call{Call: _e.mock.On("DeletePlacementGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeletePlacementGroup_Call) Run(run func(ctx context.Context, params *ec2.DeletePlacementGroupInput, optFns ...func(*ec2.Options))) *EC2_DeletePlacementGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeletePlacementGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeletePlacementGroup_Call) Return(_a0 *ec2.DeletePlacementGroupOutput, _a1 error) *EC2_DeletePlacementGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeletePlacementGroup_Call) RunAndReturn(run func(context.Context, *ec2.DeletePlacementGroupInput, ...func(*ec2.Options)) (*ec2.DeletePlacementGroupOutput, error)) *EC2_DeletePlacementGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePublicIpv4Pool provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeletePublicIpv4Pool(ctx context.Context, params *ec2.DeletePublicIpv4PoolInput, optFns ...func(*ec2.Options)) (*ec2.DeletePublicIpv4PoolOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeletePublicIpv4Pool")
	}

	var r0 *ec2.DeletePublicIpv4PoolOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeletePublicIpv4PoolInput, ...func(*ec2.Options)) (*ec2.DeletePublicIpv4PoolOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeletePublicIpv4PoolInput, ...func(*ec2.Options)) *ec2.DeletePublicIpv4PoolOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeletePublicIpv4PoolOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeletePublicIpv4PoolInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeletePublicIpv4Pool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePublicIpv4Pool'
type EC2_DeletePublicIpv4Pool_Call struct {
	*mock.Call
}

// DeletePublicIpv4Pool is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeletePublicIpv4PoolInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeletePublicIpv4Pool(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeletePublicIpv4Pool_Call {
	return &EC2_DeletePublicIpv4Pool_Call{Call: _e.mock.On("DeletePublicIpv4Pool",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeletePublicIpv4Pool_Call) Run(run func(ctx context.Context, params *ec2.DeletePublicIpv4PoolInput, optFns ...func(*ec2.Options))) *EC2_DeletePublicIpv4Pool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeletePublicIpv4PoolInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeletePublicIpv4Pool_Call) Return(_a0 *ec2.DeletePublicIpv4PoolOutput, _a1 error) *EC2_DeletePublicIpv4Pool_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeletePublicIpv4Pool_Call) RunAndReturn(run func(context.Context, *ec2.DeletePublicIpv4PoolInput, ...func(*ec2.Options)) (*ec2.DeletePublicIpv4PoolOutput, error)) *EC2_DeletePublicIpv4Pool_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteQueuedReservedInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteQueuedReservedInstances(ctx context.Context, params *ec2.DeleteQueuedReservedInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DeleteQueuedReservedInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteQueuedReservedInstances")
	}

	var r0 *ec2.DeleteQueuedReservedInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteQueuedReservedInstancesInput, ...func(*ec2.Options)) (*ec2.DeleteQueuedReservedInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteQueuedReservedInstancesInput, ...func(*ec2.Options)) *ec2.DeleteQueuedReservedInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteQueuedReservedInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteQueuedReservedInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteQueuedReservedInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteQueuedReservedInstances'
type EC2_DeleteQueuedReservedInstances_Call struct {
	*mock.Call
}

// DeleteQueuedReservedInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteQueuedReservedInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteQueuedReservedInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteQueuedReservedInstances_Call {
	return &EC2_DeleteQueuedReservedInstances_Call{Call: _e.mock.On("DeleteQueuedReservedInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteQueuedReservedInstances_Call) Run(run func(ctx context.Context, params *ec2.DeleteQueuedReservedInstancesInput, optFns ...func(*ec2.Options))) *EC2_DeleteQueuedReservedInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteQueuedReservedInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteQueuedReservedInstances_Call) Return(_a0 *ec2.DeleteQueuedReservedInstancesOutput, _a1 error) *EC2_DeleteQueuedReservedInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteQueuedReservedInstances_Call) RunAndReturn(run func(context.Context, *ec2.DeleteQueuedReservedInstancesInput, ...func(*ec2.Options)) (*ec2.DeleteQueuedReservedInstancesOutput, error)) *EC2_DeleteQueuedReservedInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteRoute(ctx context.Context, params *ec2.DeleteRouteInput, optFns ...func(*ec2.Options)) (*ec2.DeleteRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRoute")
	}

	var r0 *ec2.DeleteRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteInput, ...func(*ec2.Options)) (*ec2.DeleteRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteInput, ...func(*ec2.Options)) *ec2.DeleteRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRoute'
type EC2_DeleteRoute_Call struct {
	*mock.Call
}

// DeleteRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteRoute_Call {
	return &EC2_DeleteRoute_Call{Call: _e.mock.On("DeleteRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteRoute_Call) Run(run func(ctx context.Context, params *ec2.DeleteRouteInput, optFns ...func(*ec2.Options))) *EC2_DeleteRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteRoute_Call) Return(_a0 *ec2.DeleteRouteOutput, _a1 error) *EC2_DeleteRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteRoute_Call) RunAndReturn(run func(context.Context, *ec2.DeleteRouteInput, ...func(*ec2.Options)) (*ec2.DeleteRouteOutput, error)) *EC2_DeleteRoute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRouteServer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteRouteServer(ctx context.Context, params *ec2.DeleteRouteServerInput, optFns ...func(*ec2.Options)) (*ec2.DeleteRouteServerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRouteServer")
	}

	var r0 *ec2.DeleteRouteServerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteServerInput, ...func(*ec2.Options)) (*ec2.DeleteRouteServerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteServerInput, ...func(*ec2.Options)) *ec2.DeleteRouteServerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteServerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteRouteServerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteRouteServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRouteServer'
type EC2_DeleteRouteServer_Call struct {
	*mock.Call
}

// DeleteRouteServer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteRouteServerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteRouteServer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteRouteServer_Call {
	return &EC2_DeleteRouteServer_Call{Call: _e.mock.On("DeleteRouteServer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteRouteServer_Call) Run(run func(ctx context.Context, params *ec2.DeleteRouteServerInput, optFns ...func(*ec2.Options))) *EC2_DeleteRouteServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteRouteServerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteRouteServer_Call) Return(_a0 *ec2.DeleteRouteServerOutput, _a1 error) *EC2_DeleteRouteServer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteRouteServer_Call) RunAndReturn(run func(context.Context, *ec2.DeleteRouteServerInput, ...func(*ec2.Options)) (*ec2.DeleteRouteServerOutput, error)) *EC2_DeleteRouteServer_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRouteServerEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteRouteServerEndpoint(ctx context.Context, params *ec2.DeleteRouteServerEndpointInput, optFns ...func(*ec2.Options)) (*ec2.DeleteRouteServerEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRouteServerEndpoint")
	}

	var r0 *ec2.DeleteRouteServerEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteServerEndpointInput, ...func(*ec2.Options)) (*ec2.DeleteRouteServerEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteServerEndpointInput, ...func(*ec2.Options)) *ec2.DeleteRouteServerEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteServerEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteRouteServerEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteRouteServerEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRouteServerEndpoint'
type EC2_DeleteRouteServerEndpoint_Call struct {
	*mock.Call
}

// DeleteRouteServerEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteRouteServerEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteRouteServerEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteRouteServerEndpoint_Call {
	return &EC2_DeleteRouteServerEndpoint_Call{Call: _e.mock.On("DeleteRouteServerEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteRouteServerEndpoint_Call) Run(run func(ctx context.Context, params *ec2.DeleteRouteServerEndpointInput, optFns ...func(*ec2.Options))) *EC2_DeleteRouteServerEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteRouteServerEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteRouteServerEndpoint_Call) Return(_a0 *ec2.DeleteRouteServerEndpointOutput, _a1 error) *EC2_DeleteRouteServerEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteRouteServerEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.DeleteRouteServerEndpointInput, ...func(*ec2.Options)) (*ec2.DeleteRouteServerEndpointOutput, error)) *EC2_DeleteRouteServerEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRouteServerPeer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteRouteServerPeer(ctx context.Context, params *ec2.DeleteRouteServerPeerInput, optFns ...func(*ec2.Options)) (*ec2.DeleteRouteServerPeerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRouteServerPeer")
	}

	var r0 *ec2.DeleteRouteServerPeerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteServerPeerInput, ...func(*ec2.Options)) (*ec2.DeleteRouteServerPeerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteServerPeerInput, ...func(*ec2.Options)) *ec2.DeleteRouteServerPeerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteServerPeerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteRouteServerPeerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteRouteServerPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRouteServerPeer'
type EC2_DeleteRouteServerPeer_Call struct {
	*mock.Call
}

// DeleteRouteServerPeer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteRouteServerPeerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteRouteServerPeer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteRouteServerPeer_Call {
	return &EC2_DeleteRouteServerPeer_Call{Call: _e.mock.On("DeleteRouteServerPeer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteRouteServerPeer_Call) Run(run func(ctx context.Context, params *ec2.DeleteRouteServerPeerInput, optFns ...func(*ec2.Options))) *EC2_DeleteRouteServerPeer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteRouteServerPeerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteRouteServerPeer_Call) Return(_a0 *ec2.DeleteRouteServerPeerOutput, _a1 error) *EC2_DeleteRouteServerPeer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteRouteServerPeer_Call) RunAndReturn(run func(context.Context, *ec2.DeleteRouteServerPeerInput, ...func(*ec2.Options)) (*ec2.DeleteRouteServerPeerOutput, error)) *EC2_DeleteRouteServerPeer_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteRouteTable(ctx context.Context, params *ec2.DeleteRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.DeleteRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRouteTable")
	}

	var r0 *ec2.DeleteRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteTableInput, ...func(*ec2.Options)) (*ec2.DeleteRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteRouteTableInput, ...func(*ec2.Options)) *ec2.DeleteRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRouteTable'
type EC2_DeleteRouteTable_Call struct {
	*mock.Call
}

// DeleteRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteRouteTable_Call {
	return &EC2_DeleteRouteTable_Call{Call: _e.mock.On("DeleteRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteRouteTable_Call) Run(run func(ctx context.Context, params *ec2.DeleteRouteTableInput, optFns ...func(*ec2.Options))) *EC2_DeleteRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteRouteTable_Call) Return(_a0 *ec2.DeleteRouteTableOutput, _a1 error) *EC2_DeleteRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.DeleteRouteTableInput, ...func(*ec2.Options)) (*ec2.DeleteRouteTableOutput, error)) *EC2_DeleteRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSecurityGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteSecurityGroup(ctx context.Context, params *ec2.DeleteSecurityGroupInput, optFns ...func(*ec2.Options)) (*ec2.DeleteSecurityGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteSecurityGroup")
	}

	var r0 *ec2.DeleteSecurityGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSecurityGroupInput, ...func(*ec2.Options)) (*ec2.DeleteSecurityGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSecurityGroupInput, ...func(*ec2.Options)) *ec2.DeleteSecurityGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSecurityGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteSecurityGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteSecurityGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSecurityGroup'
type EC2_DeleteSecurityGroup_Call struct {
	*mock.Call
}

// DeleteSecurityGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteSecurityGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteSecurityGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteSecurityGroup_Call {
	return &EC2_DeleteSecurityGroup_Call{Call: _e.mock.On("DeleteSecurityGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteSecurityGroup_Call) Run(run func(ctx context.Context, params *ec2.DeleteSecurityGroupInput, optFns ...func(*ec2.Options))) *EC2_DeleteSecurityGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteSecurityGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteSecurityGroup_Call) Return(_a0 *ec2.DeleteSecurityGroupOutput, _a1 error) *EC2_DeleteSecurityGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteSecurityGroup_Call) RunAndReturn(run func(context.Context, *ec2.DeleteSecurityGroupInput, ...func(*ec2.Options)) (*ec2.DeleteSecurityGroupOutput, error)) *EC2_DeleteSecurityGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSnapshot provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteSnapshot(ctx context.Context, params *ec2.DeleteSnapshotInput, optFns ...func(*ec2.Options)) (*ec2.DeleteSnapshotOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteSnapshot")
	}

	var r0 *ec2.DeleteSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSnapshotInput, ...func(*ec2.Options)) (*ec2.DeleteSnapshotOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSnapshotInput, ...func(*ec2.Options)) *ec2.DeleteSnapshotOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSnapshotOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteSnapshotInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSnapshot'
type EC2_DeleteSnapshot_Call struct {
	*mock.Call
}

// DeleteSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteSnapshotInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteSnapshot(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteSnapshot_Call {
	return &EC2_DeleteSnapshot_Call{Call: _e.mock.On("DeleteSnapshot",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteSnapshot_Call) Run(run func(ctx context.Context, params *ec2.DeleteSnapshotInput, optFns ...func(*ec2.Options))) *EC2_DeleteSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteSnapshotInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteSnapshot_Call) Return(_a0 *ec2.DeleteSnapshotOutput, _a1 error) *EC2_DeleteSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteSnapshot_Call) RunAndReturn(run func(context.Context, *ec2.DeleteSnapshotInput, ...func(*ec2.Options)) (*ec2.DeleteSnapshotOutput, error)) *EC2_DeleteSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSpotDatafeedSubscription provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteSpotDatafeedSubscription(ctx context.Context, params *ec2.DeleteSpotDatafeedSubscriptionInput, optFns ...func(*ec2.Options)) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteSpotDatafeedSubscription")
	}

	var r0 *ec2.DeleteSpotDatafeedSubscriptionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) *ec2.DeleteSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSpotDatafeedSubscriptionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteSpotDatafeedSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSpotDatafeedSubscription'
type EC2_DeleteSpotDatafeedSubscription_Call struct {
	*mock.Call
}

// DeleteSpotDatafeedSubscription is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteSpotDatafeedSubscriptionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteSpotDatafeedSubscription(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteSpotDatafeedSubscription_Call {
	return &EC2_DeleteSpotDatafeedSubscription_Call{Call: _e.mock.On("DeleteSpotDatafeedSubscription",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteSpotDatafeedSubscription_Call) Run(run func(ctx context.Context, params *ec2.DeleteSpotDatafeedSubscriptionInput, optFns ...func(*ec2.Options))) *EC2_DeleteSpotDatafeedSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteSpotDatafeedSubscriptionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteSpotDatafeedSubscription_Call) Return(_a0 *ec2.DeleteSpotDatafeedSubscriptionOutput, _a1 error) *EC2_DeleteSpotDatafeedSubscription_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteSpotDatafeedSubscription_Call) RunAndReturn(run func(context.Context, *ec2.DeleteSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error)) *EC2_DeleteSpotDatafeedSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSubnet provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteSubnet(ctx context.Context, params *ec2.DeleteSubnetInput, optFns ...func(*ec2.Options)) (*ec2.DeleteSubnetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteSubnet")
	}

	var r0 *ec2.DeleteSubnetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSubnetInput, ...func(*ec2.Options)) (*ec2.DeleteSubnetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSubnetInput, ...func(*ec2.Options)) *ec2.DeleteSubnetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSubnetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteSubnetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteSubnet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSubnet'
type EC2_DeleteSubnet_Call struct {
	*mock.Call
}

// DeleteSubnet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteSubnetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteSubnet(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteSubnet_Call {
	return &EC2_DeleteSubnet_Call{Call: _e.mock.On("DeleteSubnet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteSubnet_Call) Run(run func(ctx context.Context, params *ec2.DeleteSubnetInput, optFns ...func(*ec2.Options))) *EC2_DeleteSubnet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteSubnetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteSubnet_Call) Return(_a0 *ec2.DeleteSubnetOutput, _a1 error) *EC2_DeleteSubnet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteSubnet_Call) RunAndReturn(run func(context.Context, *ec2.DeleteSubnetInput, ...func(*ec2.Options)) (*ec2.DeleteSubnetOutput, error)) *EC2_DeleteSubnet_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSubnetCidrReservation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteSubnetCidrReservation(ctx context.Context, params *ec2.DeleteSubnetCidrReservationInput, optFns ...func(*ec2.Options)) (*ec2.DeleteSubnetCidrReservationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteSubnetCidrReservation")
	}

	var r0 *ec2.DeleteSubnetCidrReservationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSubnetCidrReservationInput, ...func(*ec2.Options)) (*ec2.DeleteSubnetCidrReservationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteSubnetCidrReservationInput, ...func(*ec2.Options)) *ec2.DeleteSubnetCidrReservationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteSubnetCidrReservationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteSubnetCidrReservationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteSubnetCidrReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSubnetCidrReservation'
type EC2_DeleteSubnetCidrReservation_Call struct {
	*mock.Call
}

// DeleteSubnetCidrReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteSubnetCidrReservationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteSubnetCidrReservation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteSubnetCidrReservation_Call {
	return &EC2_DeleteSubnetCidrReservation_Call{Call: _e.mock.On("DeleteSubnetCidrReservation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteSubnetCidrReservation_Call) Run(run func(ctx context.Context, params *ec2.DeleteSubnetCidrReservationInput, optFns ...func(*ec2.Options))) *EC2_DeleteSubnetCidrReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteSubnetCidrReservationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteSubnetCidrReservation_Call) Return(_a0 *ec2.DeleteSubnetCidrReservationOutput, _a1 error) *EC2_DeleteSubnetCidrReservation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteSubnetCidrReservation_Call) RunAndReturn(run func(context.Context, *ec2.DeleteSubnetCidrReservationInput, ...func(*ec2.Options)) (*ec2.DeleteSubnetCidrReservationOutput, error)) *EC2_DeleteSubnetCidrReservation_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTags provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTags(ctx context.Context, params *ec2.DeleteTagsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTagsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTags")
	}

	var r0 *ec2.DeleteTagsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTagsInput, ...func(*ec2.Options)) (*ec2.DeleteTagsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTagsInput, ...func(*ec2.Options)) *ec2.DeleteTagsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTagsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTagsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTags'
type EC2_DeleteTags_Call struct {
	*mock.Call
}

// DeleteTags is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTagsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTags(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTags_Call {
	return &EC2_DeleteTags_Call{Call: _e.mock.On("DeleteTags",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTags_Call) Run(run func(ctx context.Context, params *ec2.DeleteTagsInput, optFns ...func(*ec2.Options))) *EC2_DeleteTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTagsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTags_Call) Return(_a0 *ec2.DeleteTagsOutput, _a1 error) *EC2_DeleteTags_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTags_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTagsInput, ...func(*ec2.Options)) (*ec2.DeleteTagsOutput, error)) *EC2_DeleteTags_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTrafficMirrorFilter provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTrafficMirrorFilter(ctx context.Context, params *ec2.DeleteTrafficMirrorFilterInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorFilterOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTrafficMirrorFilter")
	}

	var r0 *ec2.DeleteTrafficMirrorFilterOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorFilterInput, ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorFilterOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorFilterInput, ...func(*ec2.Options)) *ec2.DeleteTrafficMirrorFilterOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorFilterOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTrafficMirrorFilterInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTrafficMirrorFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTrafficMirrorFilter'
type EC2_DeleteTrafficMirrorFilter_Call struct {
	*mock.Call
}

// DeleteTrafficMirrorFilter is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTrafficMirrorFilterInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTrafficMirrorFilter(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTrafficMirrorFilter_Call {
	return &EC2_DeleteTrafficMirrorFilter_Call{Call: _e.mock.On("DeleteTrafficMirrorFilter",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTrafficMirrorFilter_Call) Run(run func(ctx context.Context, params *ec2.DeleteTrafficMirrorFilterInput, optFns ...func(*ec2.Options))) *EC2_DeleteTrafficMirrorFilter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTrafficMirrorFilterInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTrafficMirrorFilter_Call) Return(_a0 *ec2.DeleteTrafficMirrorFilterOutput, _a1 error) *EC2_DeleteTrafficMirrorFilter_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTrafficMirrorFilter_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTrafficMirrorFilterInput, ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorFilterOutput, error)) *EC2_DeleteTrafficMirrorFilter_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTrafficMirrorFilterRule provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTrafficMirrorFilterRule(ctx context.Context, params *ec2.DeleteTrafficMirrorFilterRuleInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTrafficMirrorFilterRule")
	}

	var r0 *ec2.DeleteTrafficMirrorFilterRuleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) *ec2.DeleteTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorFilterRuleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTrafficMirrorFilterRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTrafficMirrorFilterRule'
type EC2_DeleteTrafficMirrorFilterRule_Call struct {
	*mock.Call
}

// DeleteTrafficMirrorFilterRule is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTrafficMirrorFilterRuleInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTrafficMirrorFilterRule(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTrafficMirrorFilterRule_Call {
	return &EC2_DeleteTrafficMirrorFilterRule_Call{Call: _e.mock.On("DeleteTrafficMirrorFilterRule",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTrafficMirrorFilterRule_Call) Run(run func(ctx context.Context, params *ec2.DeleteTrafficMirrorFilterRuleInput, optFns ...func(*ec2.Options))) *EC2_DeleteTrafficMirrorFilterRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTrafficMirrorFilterRuleInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTrafficMirrorFilterRule_Call) Return(_a0 *ec2.DeleteTrafficMirrorFilterRuleOutput, _a1 error) *EC2_DeleteTrafficMirrorFilterRule_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTrafficMirrorFilterRule_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error)) *EC2_DeleteTrafficMirrorFilterRule_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTrafficMirrorSession provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTrafficMirrorSession(ctx context.Context, params *ec2.DeleteTrafficMirrorSessionInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorSessionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTrafficMirrorSession")
	}

	var r0 *ec2.DeleteTrafficMirrorSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorSessionInput, ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorSessionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorSessionInput, ...func(*ec2.Options)) *ec2.DeleteTrafficMirrorSessionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorSessionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTrafficMirrorSessionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTrafficMirrorSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTrafficMirrorSession'
type EC2_DeleteTrafficMirrorSession_Call struct {
	*mock.Call
}

// DeleteTrafficMirrorSession is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTrafficMirrorSessionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTrafficMirrorSession(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTrafficMirrorSession_Call {
	return &EC2_DeleteTrafficMirrorSession_Call{Call: _e.mock.On("DeleteTrafficMirrorSession",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTrafficMirrorSession_Call) Run(run func(ctx context.Context, params *ec2.DeleteTrafficMirrorSessionInput, optFns ...func(*ec2.Options))) *EC2_DeleteTrafficMirrorSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTrafficMirrorSessionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTrafficMirrorSession_Call) Return(_a0 *ec2.DeleteTrafficMirrorSessionOutput, _a1 error) *EC2_DeleteTrafficMirrorSession_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTrafficMirrorSession_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTrafficMirrorSessionInput, ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorSessionOutput, error)) *EC2_DeleteTrafficMirrorSession_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTrafficMirrorTarget provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTrafficMirrorTarget(ctx context.Context, params *ec2.DeleteTrafficMirrorTargetInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorTargetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTrafficMirrorTarget")
	}

	var r0 *ec2.DeleteTrafficMirrorTargetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorTargetInput, ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorTargetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTrafficMirrorTargetInput, ...func(*ec2.Options)) *ec2.DeleteTrafficMirrorTargetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTrafficMirrorTargetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTrafficMirrorTargetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTrafficMirrorTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTrafficMirrorTarget'
type EC2_DeleteTrafficMirrorTarget_Call struct {
	*mock.Call
}

// DeleteTrafficMirrorTarget is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTrafficMirrorTargetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTrafficMirrorTarget(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTrafficMirrorTarget_Call {
	return &EC2_DeleteTrafficMirrorTarget_Call{Call: _e.mock.On("DeleteTrafficMirrorTarget",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTrafficMirrorTarget_Call) Run(run func(ctx context.Context, params *ec2.DeleteTrafficMirrorTargetInput, optFns ...func(*ec2.Options))) *EC2_DeleteTrafficMirrorTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTrafficMirrorTargetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTrafficMirrorTarget_Call) Return(_a0 *ec2.DeleteTrafficMirrorTargetOutput, _a1 error) *EC2_DeleteTrafficMirrorTarget_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTrafficMirrorTarget_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTrafficMirrorTargetInput, ...func(*ec2.Options)) (*ec2.DeleteTrafficMirrorTargetOutput, error)) *EC2_DeleteTrafficMirrorTarget_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGateway(ctx context.Context, params *ec2.DeleteTransitGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGateway")
	}

	var r0 *ec2.DeleteTransitGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGateway'
type EC2_DeleteTransitGateway_Call struct {
	*mock.Call
}

// DeleteTransitGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGateway_Call {
	return &EC2_DeleteTransitGateway_Call{Call: _e.mock.On("DeleteTransitGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGateway_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGateway_Call) Return(_a0 *ec2.DeleteTransitGatewayOutput, _a1 error) *EC2_DeleteTransitGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGateway_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayOutput, error)) *EC2_DeleteTransitGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayConnect provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayConnect(ctx context.Context, params *ec2.DeleteTransitGatewayConnectInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayConnectOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayConnect")
	}

	var r0 *ec2.DeleteTransitGatewayConnectOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayConnectInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayConnectOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayConnectInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayConnectOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayConnectOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayConnectInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayConnect'
type EC2_DeleteTransitGatewayConnect_Call struct {
	*mock.Call
}

// DeleteTransitGatewayConnect is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayConnectInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayConnect(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayConnect_Call {
	return &EC2_DeleteTransitGatewayConnect_Call{Call: _e.mock.On("DeleteTransitGatewayConnect",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayConnect_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayConnectInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayConnect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayConnectInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayConnect_Call) Return(_a0 *ec2.DeleteTransitGatewayConnectOutput, _a1 error) *EC2_DeleteTransitGatewayConnect_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayConnect_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayConnectInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayConnectOutput, error)) *EC2_DeleteTransitGatewayConnect_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayConnectPeer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayConnectPeer(ctx context.Context, params *ec2.DeleteTransitGatewayConnectPeerInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayConnectPeer")
	}

	var r0 *ec2.DeleteTransitGatewayConnectPeerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayConnectPeerInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayConnectPeerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayConnectPeerInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayConnectPeerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayConnectPeerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayConnectPeerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayConnectPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayConnectPeer'
type EC2_DeleteTransitGatewayConnectPeer_Call struct {
	*mock.Call
}

// DeleteTransitGatewayConnectPeer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayConnectPeerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayConnectPeer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayConnectPeer_Call {
	return &EC2_DeleteTransitGatewayConnectPeer_Call{Call: _e.mock.On("DeleteTransitGatewayConnectPeer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayConnectPeer_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayConnectPeerInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayConnectPeer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayConnectPeerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayConnectPeer_Call) Return(_a0 *ec2.DeleteTransitGatewayConnectPeerOutput, _a1 error) *EC2_DeleteTransitGatewayConnectPeer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayConnectPeer_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayConnectPeerInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayConnectPeerOutput, error)) *EC2_DeleteTransitGatewayConnectPeer_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayMeteringPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayMeteringPolicy")
	}

	var r0 *ec2.DeleteTransitGatewayMeteringPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayMeteringPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayMeteringPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayMeteringPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayMeteringPolicy'
type EC2_DeleteTransitGatewayMeteringPolicy_Call struct {
	*mock.Call
}

// DeleteTransitGatewayMeteringPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayMeteringPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayMeteringPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayMeteringPolicy_Call {
	return &EC2_DeleteTransitGatewayMeteringPolicy_Call{Call: _e.mock.On("DeleteTransitGatewayMeteringPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayMeteringPolicy_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayMeteringPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayMeteringPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayMeteringPolicy_Call) Return(_a0 *ec2.DeleteTransitGatewayMeteringPolicyOutput, _a1 error) *EC2_DeleteTransitGatewayMeteringPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayMeteringPolicy_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyOutput, error)) *EC2_DeleteTransitGatewayMeteringPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayMeteringPolicyEntry provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayMeteringPolicyEntry(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayMeteringPolicyEntry")
	}

	var r0 *ec2.DeleteTransitGatewayMeteringPolicyEntryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayMeteringPolicyEntryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayMeteringPolicyEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayMeteringPolicyEntry'
type EC2_DeleteTransitGatewayMeteringPolicyEntry_Call struct {
	*mock.Call
}

// DeleteTransitGatewayMeteringPolicyEntry is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayMeteringPolicyEntryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayMeteringPolicyEntry(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call {
	return &EC2_DeleteTransitGatewayMeteringPolicyEntry_Call{Call: _e.mock.On("DeleteTransitGatewayMeteringPolicyEntry",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayMeteringPolicyEntryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call) Return(_a0 *ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, _a1 error) *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayMeteringPolicyEntryInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMeteringPolicyEntryOutput, error)) *EC2_DeleteTransitGatewayMeteringPolicyEntry_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayMulticastDomain provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayMulticastDomain(ctx context.Context, params *ec2.DeleteTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayMulticastDomain")
	}

	var r0 *ec2.DeleteTransitGatewayMulticastDomainOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayMulticastDomainOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayMulticastDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayMulticastDomain'
type EC2_DeleteTransitGatewayMulticastDomain_Call struct {
	*mock.Call
}

// DeleteTransitGatewayMulticastDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayMulticastDomainInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayMulticastDomain(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayMulticastDomain_Call {
	return &EC2_DeleteTransitGatewayMulticastDomain_Call{Call: _e.mock.On("DeleteTransitGatewayMulticastDomain",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayMulticastDomain_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayMulticastDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayMulticastDomainInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayMulticastDomain_Call) Return(_a0 *ec2.DeleteTransitGatewayMulticastDomainOutput, _a1 error) *EC2_DeleteTransitGatewayMulticastDomain_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayMulticastDomain_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error)) *EC2_DeleteTransitGatewayMulticastDomain_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayPeeringAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayPeeringAttachment(ctx context.Context, params *ec2.DeleteTransitGatewayPeeringAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayPeeringAttachment")
	}

	var r0 *ec2.DeleteTransitGatewayPeeringAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayPeeringAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayPeeringAttachment'
type EC2_DeleteTransitGatewayPeeringAttachment_Call struct {
	*mock.Call
}

// DeleteTransitGatewayPeeringAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayPeeringAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayPeeringAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayPeeringAttachment_Call {
	return &EC2_DeleteTransitGatewayPeeringAttachment_Call{Call: _e.mock.On("DeleteTransitGatewayPeeringAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayPeeringAttachment_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayPeeringAttachmentInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayPeeringAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayPeeringAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayPeeringAttachment_Call) Return(_a0 *ec2.DeleteTransitGatewayPeeringAttachmentOutput, _a1 error) *EC2_DeleteTransitGatewayPeeringAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayPeeringAttachment_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error)) *EC2_DeleteTransitGatewayPeeringAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayPolicyTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayPolicyTable(ctx context.Context, params *ec2.DeleteTransitGatewayPolicyTableInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPolicyTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayPolicyTable")
	}

	var r0 *ec2.DeleteTransitGatewayPolicyTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayPolicyTableInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPolicyTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayPolicyTableInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayPolicyTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayPolicyTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayPolicyTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayPolicyTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayPolicyTable'
type EC2_DeleteTransitGatewayPolicyTable_Call struct {
	*mock.Call
}

// DeleteTransitGatewayPolicyTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayPolicyTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayPolicyTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayPolicyTable_Call {
	return &EC2_DeleteTransitGatewayPolicyTable_Call{Call: _e.mock.On("DeleteTransitGatewayPolicyTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayPolicyTable_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayPolicyTableInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayPolicyTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayPolicyTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayPolicyTable_Call) Return(_a0 *ec2.DeleteTransitGatewayPolicyTableOutput, _a1 error) *EC2_DeleteTransitGatewayPolicyTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayPolicyTable_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayPolicyTableInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPolicyTableOutput, error)) *EC2_DeleteTransitGatewayPolicyTable_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayPrefixListReference provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayPrefixListReference(ctx context.Context, params *ec2.DeleteTransitGatewayPrefixListReferenceInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayPrefixListReference")
	}

	var r0 *ec2.DeleteTransitGatewayPrefixListReferenceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayPrefixListReference_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayPrefixListReference'
type EC2_DeleteTransitGatewayPrefixListReference_Call struct {
	*mock.Call
}

// DeleteTransitGatewayPrefixListReference is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayPrefixListReferenceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayPrefixListReference(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayPrefixListReference_Call {
	return &EC2_DeleteTransitGatewayPrefixListReference_Call{Call: _e.mock.On("DeleteTransitGatewayPrefixListReference",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayPrefixListReference_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayPrefixListReferenceInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayPrefixListReference_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayPrefixListReferenceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayPrefixListReference_Call) Return(_a0 *ec2.DeleteTransitGatewayPrefixListReferenceOutput, _a1 error) *EC2_DeleteTransitGatewayPrefixListReference_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayPrefixListReference_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error)) *EC2_DeleteTransitGatewayPrefixListReference_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayRoute(ctx context.Context, params *ec2.DeleteTransitGatewayRouteInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayRoute")
	}

	var r0 *ec2.DeleteTransitGatewayRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayRouteInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayRouteInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayRoute'
type EC2_DeleteTransitGatewayRoute_Call struct {
	*mock.Call
}

// DeleteTransitGatewayRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayRoute_Call {
	return &EC2_DeleteTransitGatewayRoute_Call{Call: _e.mock.On("DeleteTransitGatewayRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayRoute_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayRouteInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayRoute_Call) Return(_a0 *ec2.DeleteTransitGatewayRouteOutput, _a1 error) *EC2_DeleteTransitGatewayRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayRoute_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayRouteInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteOutput, error)) *EC2_DeleteTransitGatewayRoute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayRouteTable(ctx context.Context, params *ec2.DeleteTransitGatewayRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayRouteTable")
	}

	var r0 *ec2.DeleteTransitGatewayRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayRouteTableInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayRouteTable'
type EC2_DeleteTransitGatewayRouteTable_Call struct {
	*mock.Call
}

// DeleteTransitGatewayRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayRouteTable_Call {
	return &EC2_DeleteTransitGatewayRouteTable_Call{Call: _e.mock.On("DeleteTransitGatewayRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayRouteTable_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayRouteTableInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayRouteTable_Call) Return(_a0 *ec2.DeleteTransitGatewayRouteTableOutput, _a1 error) *EC2_DeleteTransitGatewayRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteTableOutput, error)) *EC2_DeleteTransitGatewayRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayRouteTableAnnouncement provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayRouteTableAnnouncement(ctx context.Context, params *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayRouteTableAnnouncement")
	}

	var r0 *ec2.DeleteTransitGatewayRouteTableAnnouncementOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayRouteTableAnnouncementOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayRouteTableAnnouncement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayRouteTableAnnouncement'
type EC2_DeleteTransitGatewayRouteTableAnnouncement_Call struct {
	*mock.Call
}

// DeleteTransitGatewayRouteTableAnnouncement is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayRouteTableAnnouncementInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayRouteTableAnnouncement(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayRouteTableAnnouncement_Call {
	return &EC2_DeleteTransitGatewayRouteTableAnnouncement_Call{Call: _e.mock.On("DeleteTransitGatewayRouteTableAnnouncement",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayRouteTableAnnouncement_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayRouteTableAnnouncement_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayRouteTableAnnouncementInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayRouteTableAnnouncement_Call) Return(_a0 *ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, _a1 error) *EC2_DeleteTransitGatewayRouteTableAnnouncement_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayRouteTableAnnouncement_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error)) *EC2_DeleteTransitGatewayRouteTableAnnouncement_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTransitGatewayVpcAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteTransitGatewayVpcAttachment(ctx context.Context, params *ec2.DeleteTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTransitGatewayVpcAttachment")
	}

	var r0 *ec2.DeleteTransitGatewayVpcAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) *ec2.DeleteTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteTransitGatewayVpcAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTransitGatewayVpcAttachment'
type EC2_DeleteTransitGatewayVpcAttachment_Call struct {
	*mock.Call
}

// DeleteTransitGatewayVpcAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteTransitGatewayVpcAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteTransitGatewayVpcAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteTransitGatewayVpcAttachment_Call {
	return &EC2_DeleteTransitGatewayVpcAttachment_Call{Call: _e.mock.On("DeleteTransitGatewayVpcAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteTransitGatewayVpcAttachment_Call) Run(run func(ctx context.Context, params *ec2.DeleteTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options))) *EC2_DeleteTransitGatewayVpcAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteTransitGatewayVpcAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteTransitGatewayVpcAttachment_Call) Return(_a0 *ec2.DeleteTransitGatewayVpcAttachmentOutput, _a1 error) *EC2_DeleteTransitGatewayVpcAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteTransitGatewayVpcAttachment_Call) RunAndReturn(run func(context.Context, *ec2.DeleteTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error)) *EC2_DeleteTransitGatewayVpcAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVerifiedAccessEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVerifiedAccessEndpoint(ctx context.Context, params *ec2.DeleteVerifiedAccessEndpointInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVerifiedAccessEndpoint")
	}

	var r0 *ec2.DeleteVerifiedAccessEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVerifiedAccessEndpointInput, ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVerifiedAccessEndpointInput, ...func(*ec2.Options)) *ec2.DeleteVerifiedAccessEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVerifiedAccessEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVerifiedAccessEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVerifiedAccessEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVerifiedAccessEndpoint'
type EC2_DeleteVerifiedAccessEndpoint_Call struct {
	*mock.Call
}

// DeleteVerifiedAccessEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVerifiedAccessEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVerifiedAccessEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVerifiedAccessEndpoint_Call {
	return &EC2_DeleteVerifiedAccessEndpoint_Call{Call: _e.mock.On("DeleteVerifiedAccessEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVerifiedAccessEndpoint_Call) Run(run func(ctx context.Context, params *ec2.DeleteVerifiedAccessEndpointInput, optFns ...func(*ec2.Options))) *EC2_DeleteVerifiedAccessEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVerifiedAccessEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVerifiedAccessEndpoint_Call) Return(_a0 *ec2.DeleteVerifiedAccessEndpointOutput, _a1 error) *EC2_DeleteVerifiedAccessEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVerifiedAccessEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVerifiedAccessEndpointInput, ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessEndpointOutput, error)) *EC2_DeleteVerifiedAccessEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVerifiedAccessGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVerifiedAccessGroup(ctx context.Context, params *ec2.DeleteVerifiedAccessGroupInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVerifiedAccessGroup")
	}

	var r0 *ec2.DeleteVerifiedAccessGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVerifiedAccessGroupInput, ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVerifiedAccessGroupInput, ...func(*ec2.Options)) *ec2.DeleteVerifiedAccessGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVerifiedAccessGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVerifiedAccessGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVerifiedAccessGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVerifiedAccessGroup'
type EC2_DeleteVerifiedAccessGroup_Call struct {
	*mock.Call
}

// DeleteVerifiedAccessGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVerifiedAccessGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVerifiedAccessGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVerifiedAccessGroup_Call {
	return &EC2_DeleteVerifiedAccessGroup_Call{Call: _e.mock.On("DeleteVerifiedAccessGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVerifiedAccessGroup_Call) Run(run func(ctx context.Context, params *ec2.DeleteVerifiedAccessGroupInput, optFns ...func(*ec2.Options))) *EC2_DeleteVerifiedAccessGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVerifiedAccessGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVerifiedAccessGroup_Call) Return(_a0 *ec2.DeleteVerifiedAccessGroupOutput, _a1 error) *EC2_DeleteVerifiedAccessGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVerifiedAccessGroup_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVerifiedAccessGroupInput, ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessGroupOutput, error)) *EC2_DeleteVerifiedAccessGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVerifiedAccessInstance provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVerifiedAccessInstance(ctx context.Context, params *ec2.DeleteVerifiedAccessInstanceInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessInstanceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVerifiedAccessInstance")
	}

	var r0 *ec2.DeleteVerifiedAccessInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVerifiedAccessInstanceInput, ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessInstanceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVerifiedAccessInstanceInput, ...func(*ec2.Options)) *ec2.DeleteVerifiedAccessInstanceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVerifiedAccessInstanceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVerifiedAccessInstanceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVerifiedAccessInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVerifiedAccessInstance'
type EC2_DeleteVerifiedAccessInstance_Call struct {
	*mock.Call
}

// DeleteVerifiedAccessInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVerifiedAccessInstanceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVerifiedAccessInstance(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVerifiedAccessInstance_Call {
	return &EC2_DeleteVerifiedAccessInstance_Call{Call: _e.mock.On("DeleteVerifiedAccessInstance",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVerifiedAccessInstance_Call) Run(run func(ctx context.Context, params *ec2.DeleteVerifiedAccessInstanceInput, optFns ...func(*ec2.Options))) *EC2_DeleteVerifiedAccessInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVerifiedAccessInstanceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVerifiedAccessInstance_Call) Return(_a0 *ec2.DeleteVerifiedAccessInstanceOutput, _a1 error) *EC2_DeleteVerifiedAccessInstance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVerifiedAccessInstance_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVerifiedAccessInstanceInput, ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessInstanceOutput, error)) *EC2_DeleteVerifiedAccessInstance_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVerifiedAccessTrustProvider provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVerifiedAccessTrustProvider(ctx context.Context, params *ec2.DeleteVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVerifiedAccessTrustProvider")
	}

	var r0 *ec2.DeleteVerifiedAccessTrustProviderOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) *ec2.DeleteVerifiedAccessTrustProviderOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVerifiedAccessTrustProviderOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVerifiedAccessTrustProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVerifiedAccessTrustProvider'
type EC2_DeleteVerifiedAccessTrustProvider_Call struct {
	*mock.Call
}

// DeleteVerifiedAccessTrustProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVerifiedAccessTrustProviderInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVerifiedAccessTrustProvider(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVerifiedAccessTrustProvider_Call {
	return &EC2_DeleteVerifiedAccessTrustProvider_Call{Call: _e.mock.On("DeleteVerifiedAccessTrustProvider",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVerifiedAccessTrustProvider_Call) Run(run func(ctx context.Context, params *ec2.DeleteVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options))) *EC2_DeleteVerifiedAccessTrustProvider_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVerifiedAccessTrustProviderInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVerifiedAccessTrustProvider_Call) Return(_a0 *ec2.DeleteVerifiedAccessTrustProviderOutput, _a1 error) *EC2_DeleteVerifiedAccessTrustProvider_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVerifiedAccessTrustProvider_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error)) *EC2_DeleteVerifiedAccessTrustProvider_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVolume provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVolume(ctx context.Context, params *ec2.DeleteVolumeInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVolumeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVolume")
	}

	var r0 *ec2.DeleteVolumeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVolumeInput, ...func(*ec2.Options)) (*ec2.DeleteVolumeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVolumeInput, ...func(*ec2.Options)) *ec2.DeleteVolumeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVolumeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVolumeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVolume'
type EC2_DeleteVolume_Call struct {
	*mock.Call
}

// DeleteVolume is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVolumeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVolume(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVolume_Call {
	return &EC2_DeleteVolume_Call{Call: _e.mock.On("DeleteVolume",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVolume_Call) Run(run func(ctx context.Context, params *ec2.DeleteVolumeInput, optFns ...func(*ec2.Options))) *EC2_DeleteVolume_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVolumeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVolume_Call) Return(_a0 *ec2.DeleteVolumeOutput, _a1 error) *EC2_DeleteVolume_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVolume_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVolumeInput, ...func(*ec2.Options)) (*ec2.DeleteVolumeOutput, error)) *EC2_DeleteVolume_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpc(ctx context.Context, params *ec2.DeleteVpcInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpc")
	}

	var r0 *ec2.DeleteVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcInput, ...func(*ec2.Options)) (*ec2.DeleteVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcInput, ...func(*ec2.Options)) *ec2.DeleteVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpc'
type EC2_DeleteVpc_Call struct {
	*mock.Call
}

// DeleteVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpc_Call {
	return &EC2_DeleteVpc_Call{Call: _e.mock.On("DeleteVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpc_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpcInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpc_Call) Return(_a0 *ec2.DeleteVpcOutput, _a1 error) *EC2_DeleteVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpc_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpcInput, ...func(*ec2.Options)) (*ec2.DeleteVpcOutput, error)) *EC2_DeleteVpc_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpcBlockPublicAccessExclusion provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpcBlockPublicAccessExclusion(ctx context.Context, params *ec2.DeleteVpcBlockPublicAccessExclusionInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcBlockPublicAccessExclusionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpcBlockPublicAccessExclusion")
	}

	var r0 *ec2.DeleteVpcBlockPublicAccessExclusionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) (*ec2.DeleteVpcBlockPublicAccessExclusionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) *ec2.DeleteVpcBlockPublicAccessExclusionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcBlockPublicAccessExclusionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpcBlockPublicAccessExclusion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpcBlockPublicAccessExclusion'
type EC2_DeleteVpcBlockPublicAccessExclusion_Call struct {
	*mock.Call
}

// DeleteVpcBlockPublicAccessExclusion is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpcBlockPublicAccessExclusionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpcBlockPublicAccessExclusion(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpcBlockPublicAccessExclusion_Call {
	return &EC2_DeleteVpcBlockPublicAccessExclusion_Call{Call: _e.mock.On("DeleteVpcBlockPublicAccessExclusion",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpcBlockPublicAccessExclusion_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpcBlockPublicAccessExclusionInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpcBlockPublicAccessExclusion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpcBlockPublicAccessExclusionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpcBlockPublicAccessExclusion_Call) Return(_a0 *ec2.DeleteVpcBlockPublicAccessExclusionOutput, _a1 error) *EC2_DeleteVpcBlockPublicAccessExclusion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpcBlockPublicAccessExclusion_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) (*ec2.DeleteVpcBlockPublicAccessExclusionOutput, error)) *EC2_DeleteVpcBlockPublicAccessExclusion_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpcEncryptionControl provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpcEncryptionControl(ctx context.Context, params *ec2.DeleteVpcEncryptionControlInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEncryptionControlOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpcEncryptionControl")
	}

	var r0 *ec2.DeleteVpcEncryptionControlOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEncryptionControlOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEncryptionControlInput, ...func(*ec2.Options)) *ec2.DeleteVpcEncryptionControlOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEncryptionControlOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpcEncryptionControlInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpcEncryptionControl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpcEncryptionControl'
type EC2_DeleteVpcEncryptionControl_Call struct {
	*mock.Call
}

// DeleteVpcEncryptionControl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpcEncryptionControlInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpcEncryptionControl(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpcEncryptionControl_Call {
	return &EC2_DeleteVpcEncryptionControl_Call{Call: _e.mock.On("DeleteVpcEncryptionControl",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpcEncryptionControl_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpcEncryptionControlInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpcEncryptionControl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpcEncryptionControlInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpcEncryptionControl_Call) Return(_a0 *ec2.DeleteVpcEncryptionControlOutput, _a1 error) *EC2_DeleteVpcEncryptionControl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpcEncryptionControl_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEncryptionControlOutput, error)) *EC2_DeleteVpcEncryptionControl_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpcEndpointConnectionNotifications provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpcEndpointConnectionNotifications(ctx context.Context, params *ec2.DeleteVpcEndpointConnectionNotificationsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpcEndpointConnectionNotifications")
	}

	var r0 *ec2.DeleteVpcEndpointConnectionNotificationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointConnectionNotificationsInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointConnectionNotificationsInput, ...func(*ec2.Options)) *ec2.DeleteVpcEndpointConnectionNotificationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpcEndpointConnectionNotificationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpcEndpointConnectionNotifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpcEndpointConnectionNotifications'
type EC2_DeleteVpcEndpointConnectionNotifications_Call struct {
	*mock.Call
}

// DeleteVpcEndpointConnectionNotifications is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpcEndpointConnectionNotificationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpcEndpointConnectionNotifications(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpcEndpointConnectionNotifications_Call {
	return &EC2_DeleteVpcEndpointConnectionNotifications_Call{Call: _e.mock.On("DeleteVpcEndpointConnectionNotifications",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpcEndpointConnectionNotifications_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpcEndpointConnectionNotificationsInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpcEndpointConnectionNotifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpcEndpointConnectionNotificationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpcEndpointConnectionNotifications_Call) Return(_a0 *ec2.DeleteVpcEndpointConnectionNotificationsOutput, _a1 error) *EC2_DeleteVpcEndpointConnectionNotifications_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpcEndpointConnectionNotifications_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpcEndpointConnectionNotificationsInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error)) *EC2_DeleteVpcEndpointConnectionNotifications_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpcEndpointServiceConfigurations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpcEndpointServiceConfigurations(ctx context.Context, params *ec2.DeleteVpcEndpointServiceConfigurationsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpcEndpointServiceConfigurations")
	}

	var r0 *ec2.DeleteVpcEndpointServiceConfigurationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointServiceConfigurationsInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointServiceConfigurationsInput, ...func(*ec2.Options)) *ec2.DeleteVpcEndpointServiceConfigurationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpcEndpointServiceConfigurationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpcEndpointServiceConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpcEndpointServiceConfigurations'
type EC2_DeleteVpcEndpointServiceConfigurations_Call struct {
	*mock.Call
}

// DeleteVpcEndpointServiceConfigurations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpcEndpointServiceConfigurationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpcEndpointServiceConfigurations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpcEndpointServiceConfigurations_Call {
	return &EC2_DeleteVpcEndpointServiceConfigurations_Call{Call: _e.mock.On("DeleteVpcEndpointServiceConfigurations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpcEndpointServiceConfigurations_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpcEndpointServiceConfigurationsInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpcEndpointServiceConfigurations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpcEndpointServiceConfigurationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpcEndpointServiceConfigurations_Call) Return(_a0 *ec2.DeleteVpcEndpointServiceConfigurationsOutput, _a1 error) *EC2_DeleteVpcEndpointServiceConfigurations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpcEndpointServiceConfigurations_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpcEndpointServiceConfigurationsInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error)) *EC2_DeleteVpcEndpointServiceConfigurations_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpcEndpoints provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpcEndpoints(ctx context.Context, params *ec2.DeleteVpcEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpcEndpoints")
	}

	var r0 *ec2.DeleteVpcEndpointsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointsInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcEndpointsInput, ...func(*ec2.Options)) *ec2.DeleteVpcEndpointsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcEndpointsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpcEndpointsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpcEndpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpcEndpoints'
type EC2_DeleteVpcEndpoints_Call struct {
	*mock.Call
}

// DeleteVpcEndpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpcEndpointsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpcEndpoints(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpcEndpoints_Call {
	return &EC2_DeleteVpcEndpoints_Call{Call: _e.mock.On("DeleteVpcEndpoints",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpcEndpoints_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpcEndpointsInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpcEndpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpcEndpointsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpcEndpoints_Call) Return(_a0 *ec2.DeleteVpcEndpointsOutput, _a1 error) *EC2_DeleteVpcEndpoints_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpcEndpoints_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpcEndpointsInput, ...func(*ec2.Options)) (*ec2.DeleteVpcEndpointsOutput, error)) *EC2_DeleteVpcEndpoints_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpcPeeringConnection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpcPeeringConnection(ctx context.Context, params *ec2.DeleteVpcPeeringConnectionInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpcPeeringConnectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpcPeeringConnection")
	}

	var r0 *ec2.DeleteVpcPeeringConnectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcPeeringConnectionInput, ...func(*ec2.Options)) (*ec2.DeleteVpcPeeringConnectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpcPeeringConnectionInput, ...func(*ec2.Options)) *ec2.DeleteVpcPeeringConnectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpcPeeringConnectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpcPeeringConnectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpcPeeringConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpcPeeringConnection'
type EC2_DeleteVpcPeeringConnection_Call struct {
	*mock.Call
}

// DeleteVpcPeeringConnection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpcPeeringConnectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpcPeeringConnection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpcPeeringConnection_Call {
	return &EC2_DeleteVpcPeeringConnection_Call{Call: _e.mock.On("DeleteVpcPeeringConnection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpcPeeringConnection_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpcPeeringConnectionInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpcPeeringConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpcPeeringConnectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpcPeeringConnection_Call) Return(_a0 *ec2.DeleteVpcPeeringConnectionOutput, _a1 error) *EC2_DeleteVpcPeeringConnection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpcPeeringConnection_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpcPeeringConnectionInput, ...func(*ec2.Options)) (*ec2.DeleteVpcPeeringConnectionOutput, error)) *EC2_DeleteVpcPeeringConnection_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpnConcentrator provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpnConcentrator(ctx context.Context, params *ec2.DeleteVpnConcentratorInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpnConcentratorOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpnConcentrator")
	}

	var r0 *ec2.DeleteVpnConcentratorOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConcentratorInput, ...func(*ec2.Options)) (*ec2.DeleteVpnConcentratorOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConcentratorInput, ...func(*ec2.Options)) *ec2.DeleteVpnConcentratorOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnConcentratorOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpnConcentratorInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpnConcentrator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpnConcentrator'
type EC2_DeleteVpnConcentrator_Call struct {
	*mock.Call
}

// DeleteVpnConcentrator is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpnConcentratorInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpnConcentrator(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpnConcentrator_Call {
	return &EC2_DeleteVpnConcentrator_Call{Call: _e.mock.On("DeleteVpnConcentrator",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpnConcentrator_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpnConcentratorInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpnConcentrator_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpnConcentratorInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpnConcentrator_Call) Return(_a0 *ec2.DeleteVpnConcentratorOutput, _a1 error) *EC2_DeleteVpnConcentrator_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpnConcentrator_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpnConcentratorInput, ...func(*ec2.Options)) (*ec2.DeleteVpnConcentratorOutput, error)) *EC2_DeleteVpnConcentrator_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpnConnection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpnConnection(ctx context.Context, params *ec2.DeleteVpnConnectionInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpnConnectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpnConnection")
	}

	var r0 *ec2.DeleteVpnConnectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConnectionInput, ...func(*ec2.Options)) (*ec2.DeleteVpnConnectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConnectionInput, ...func(*ec2.Options)) *ec2.DeleteVpnConnectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnConnectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpnConnectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpnConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpnConnection'
type EC2_DeleteVpnConnection_Call struct {
	*mock.Call
}

// DeleteVpnConnection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpnConnectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpnConnection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpnConnection_Call {
	return &EC2_DeleteVpnConnection_Call{Call: _e.mock.On("DeleteVpnConnection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpnConnection_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpnConnectionInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpnConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpnConnectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpnConnection_Call) Return(_a0 *ec2.DeleteVpnConnectionOutput, _a1 error) *EC2_DeleteVpnConnection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpnConnection_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpnConnectionInput, ...func(*ec2.Options)) (*ec2.DeleteVpnConnectionOutput, error)) *EC2_DeleteVpnConnection_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpnConnectionRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpnConnectionRoute(ctx context.Context, params *ec2.DeleteVpnConnectionRouteInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpnConnectionRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpnConnectionRoute")
	}

	var r0 *ec2.DeleteVpnConnectionRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConnectionRouteInput, ...func(*ec2.Options)) (*ec2.DeleteVpnConnectionRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnConnectionRouteInput, ...func(*ec2.Options)) *ec2.DeleteVpnConnectionRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnConnectionRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpnConnectionRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpnConnectionRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpnConnectionRoute'
type EC2_DeleteVpnConnectionRoute_Call struct {
	*mock.Call
}

// DeleteVpnConnectionRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpnConnectionRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpnConnectionRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpnConnectionRoute_Call {
	return &EC2_DeleteVpnConnectionRoute_Call{Call: _e.mock.On("DeleteVpnConnectionRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpnConnectionRoute_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpnConnectionRouteInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpnConnectionRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpnConnectionRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpnConnectionRoute_Call) Return(_a0 *ec2.DeleteVpnConnectionRouteOutput, _a1 error) *EC2_DeleteVpnConnectionRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpnConnectionRoute_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpnConnectionRouteInput, ...func(*ec2.Options)) (*ec2.DeleteVpnConnectionRouteOutput, error)) *EC2_DeleteVpnConnectionRoute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteVpnGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeleteVpnGateway(ctx context.Context, params *ec2.DeleteVpnGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DeleteVpnGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteVpnGateway")
	}

	var r0 *ec2.DeleteVpnGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteVpnGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeleteVpnGatewayInput, ...func(*ec2.Options)) *ec2.DeleteVpnGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeleteVpnGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeleteVpnGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeleteVpnGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteVpnGateway'
type EC2_DeleteVpnGateway_Call struct {
	*mock.Call
}

// DeleteVpnGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeleteVpnGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeleteVpnGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeleteVpnGateway_Call {
	return &EC2_DeleteVpnGateway_Call{Call: _e.mock.On("DeleteVpnGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeleteVpnGateway_Call) Run(run func(ctx context.Context, params *ec2.DeleteVpnGatewayInput, optFns ...func(*ec2.Options))) *EC2_DeleteVpnGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeleteVpnGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeleteVpnGateway_Call) Return(_a0 *ec2.DeleteVpnGatewayOutput, _a1 error) *EC2_DeleteVpnGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeleteVpnGateway_Call) RunAndReturn(run func(context.Context, *ec2.DeleteVpnGatewayInput, ...func(*ec2.Options)) (*ec2.DeleteVpnGatewayOutput, error)) *EC2_DeleteVpnGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DeprovisionByoipCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeprovisionByoipCidr(ctx context.Context, params *ec2.DeprovisionByoipCidrInput, optFns ...func(*ec2.Options)) (*ec2.DeprovisionByoipCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeprovisionByoipCidr")
	}

	var r0 *ec2.DeprovisionByoipCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionByoipCidrInput, ...func(*ec2.Options)) (*ec2.DeprovisionByoipCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionByoipCidrInput, ...func(*ec2.Options)) *ec2.DeprovisionByoipCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeprovisionByoipCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeprovisionByoipCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeprovisionByoipCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeprovisionByoipCidr'
type EC2_DeprovisionByoipCidr_Call struct {
	*mock.Call
}

// DeprovisionByoipCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeprovisionByoipCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeprovisionByoipCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeprovisionByoipCidr_Call {
	return &EC2_DeprovisionByoipCidr_Call{Call: _e.mock.On("DeprovisionByoipCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeprovisionByoipCidr_Call) Run(run func(ctx context.Context, params *ec2.DeprovisionByoipCidrInput, optFns ...func(*ec2.Options))) *EC2_DeprovisionByoipCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeprovisionByoipCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeprovisionByoipCidr_Call) Return(_a0 *ec2.DeprovisionByoipCidrOutput, _a1 error) *EC2_DeprovisionByoipCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeprovisionByoipCidr_Call) RunAndReturn(run func(context.Context, *ec2.DeprovisionByoipCidrInput, ...func(*ec2.Options)) (*ec2.DeprovisionByoipCidrOutput, error)) *EC2_DeprovisionByoipCidr_Call {
	_c.Call.Return(run)
	return _c
}

// DeprovisionIpamByoasn provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeprovisionIpamByoasn(ctx context.Context, params *ec2.DeprovisionIpamByoasnInput, optFns ...func(*ec2.Options)) (*ec2.DeprovisionIpamByoasnOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeprovisionIpamByoasn")
	}

	var r0 *ec2.DeprovisionIpamByoasnOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionIpamByoasnInput, ...func(*ec2.Options)) (*ec2.DeprovisionIpamByoasnOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionIpamByoasnInput, ...func(*ec2.Options)) *ec2.DeprovisionIpamByoasnOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeprovisionIpamByoasnOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeprovisionIpamByoasnInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeprovisionIpamByoasn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeprovisionIpamByoasn'
type EC2_DeprovisionIpamByoasn_Call struct {
	*mock.Call
}

// DeprovisionIpamByoasn is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeprovisionIpamByoasnInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeprovisionIpamByoasn(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeprovisionIpamByoasn_Call {
	return &EC2_DeprovisionIpamByoasn_Call{Call: _e.mock.On("DeprovisionIpamByoasn",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeprovisionIpamByoasn_Call) Run(run func(ctx context.Context, params *ec2.DeprovisionIpamByoasnInput, optFns ...func(*ec2.Options))) *EC2_DeprovisionIpamByoasn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeprovisionIpamByoasnInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeprovisionIpamByoasn_Call) Return(_a0 *ec2.DeprovisionIpamByoasnOutput, _a1 error) *EC2_DeprovisionIpamByoasn_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeprovisionIpamByoasn_Call) RunAndReturn(run func(context.Context, *ec2.DeprovisionIpamByoasnInput, ...func(*ec2.Options)) (*ec2.DeprovisionIpamByoasnOutput, error)) *EC2_DeprovisionIpamByoasn_Call {
	_c.Call.Return(run)
	return _c
}

// DeprovisionIpamPoolCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeprovisionIpamPoolCidr(ctx context.Context, params *ec2.DeprovisionIpamPoolCidrInput, optFns ...func(*ec2.Options)) (*ec2.DeprovisionIpamPoolCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeprovisionIpamPoolCidr")
	}

	var r0 *ec2.DeprovisionIpamPoolCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionIpamPoolCidrInput, ...func(*ec2.Options)) (*ec2.DeprovisionIpamPoolCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionIpamPoolCidrInput, ...func(*ec2.Options)) *ec2.DeprovisionIpamPoolCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeprovisionIpamPoolCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeprovisionIpamPoolCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeprovisionIpamPoolCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeprovisionIpamPoolCidr'
type EC2_DeprovisionIpamPoolCidr_Call struct {
	*mock.Call
}

// DeprovisionIpamPoolCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeprovisionIpamPoolCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeprovisionIpamPoolCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeprovisionIpamPoolCidr_Call {
	return &EC2_DeprovisionIpamPoolCidr_Call{Call: _e.mock.On("DeprovisionIpamPoolCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeprovisionIpamPoolCidr_Call) Run(run func(ctx context.Context, params *ec2.DeprovisionIpamPoolCidrInput, optFns ...func(*ec2.Options))) *EC2_DeprovisionIpamPoolCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeprovisionIpamPoolCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeprovisionIpamPoolCidr_Call) Return(_a0 *ec2.DeprovisionIpamPoolCidrOutput, _a1 error) *EC2_DeprovisionIpamPoolCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeprovisionIpamPoolCidr_Call) RunAndReturn(run func(context.Context, *ec2.DeprovisionIpamPoolCidrInput, ...func(*ec2.Options)) (*ec2.DeprovisionIpamPoolCidrOutput, error)) *EC2_DeprovisionIpamPoolCidr_Call {
	_c.Call.Return(run)
	return _c
}

// DeprovisionPublicIpv4PoolCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeprovisionPublicIpv4PoolCidr(ctx context.Context, params *ec2.DeprovisionPublicIpv4PoolCidrInput, optFns ...func(*ec2.Options)) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeprovisionPublicIpv4PoolCidr")
	}

	var r0 *ec2.DeprovisionPublicIpv4PoolCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionPublicIpv4PoolCidrInput, ...func(*ec2.Options)) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeprovisionPublicIpv4PoolCidrInput, ...func(*ec2.Options)) *ec2.DeprovisionPublicIpv4PoolCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeprovisionPublicIpv4PoolCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeprovisionPublicIpv4PoolCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeprovisionPublicIpv4PoolCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeprovisionPublicIpv4PoolCidr'
type EC2_DeprovisionPublicIpv4PoolCidr_Call struct {
	*mock.Call
}

// DeprovisionPublicIpv4PoolCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeprovisionPublicIpv4PoolCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeprovisionPublicIpv4PoolCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeprovisionPublicIpv4PoolCidr_Call {
	return &EC2_DeprovisionPublicIpv4PoolCidr_Call{Call: _e.mock.On("DeprovisionPublicIpv4PoolCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeprovisionPublicIpv4PoolCidr_Call) Run(run func(ctx context.Context, params *ec2.DeprovisionPublicIpv4PoolCidrInput, optFns ...func(*ec2.Options))) *EC2_DeprovisionPublicIpv4PoolCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeprovisionPublicIpv4PoolCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeprovisionPublicIpv4PoolCidr_Call) Return(_a0 *ec2.DeprovisionPublicIpv4PoolCidrOutput, _a1 error) *EC2_DeprovisionPublicIpv4PoolCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeprovisionPublicIpv4PoolCidr_Call) RunAndReturn(run func(context.Context, *ec2.DeprovisionPublicIpv4PoolCidrInput, ...func(*ec2.Options)) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error)) *EC2_DeprovisionPublicIpv4PoolCidr_Call {
	_c.Call.Return(run)
	return _c
}

// DeregisterImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeregisterImage(ctx context.Context, params *ec2.DeregisterImageInput, optFns ...func(*ec2.Options)) (*ec2.DeregisterImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeregisterImage")
	}

	var r0 *ec2.DeregisterImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterImageInput, ...func(*ec2.Options)) (*ec2.DeregisterImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterImageInput, ...func(*ec2.Options)) *ec2.DeregisterImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeregisterImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeregisterImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeregisterImage'
type EC2_DeregisterImage_Call struct {
	*mock.Call
}

// DeregisterImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeregisterImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeregisterImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeregisterImage_Call {
	return &EC2_DeregisterImage_Call{Call: _e.mock.On("DeregisterImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeregisterImage_Call) Run(run func(ctx context.Context, params *ec2.DeregisterImageInput, optFns ...func(*ec2.Options))) *EC2_DeregisterImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeregisterImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeregisterImage_Call) Return(_a0 *ec2.DeregisterImageOutput, _a1 error) *EC2_DeregisterImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeregisterImage_Call) RunAndReturn(run func(context.Context, *ec2.DeregisterImageInput, ...func(*ec2.Options)) (*ec2.DeregisterImageOutput, error)) *EC2_DeregisterImage_Call {
	_c.Call.Return(run)
	return _c
}

// DeregisterInstanceEventNotificationAttributes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeregisterInstanceEventNotificationAttributes(ctx context.Context, params *ec2.DeregisterInstanceEventNotificationAttributesInput, optFns ...func(*ec2.Options)) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeregisterInstanceEventNotificationAttributes")
	}

	var r0 *ec2.DeregisterInstanceEventNotificationAttributesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) *ec2.DeregisterInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeregisterInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeregisterInstanceEventNotificationAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeregisterInstanceEventNotificationAttributes'
type EC2_DeregisterInstanceEventNotificationAttributes_Call struct {
	*mock.Call
}

// DeregisterInstanceEventNotificationAttributes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeregisterInstanceEventNotificationAttributesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeregisterInstanceEventNotificationAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeregisterInstanceEventNotificationAttributes_Call {
	return &EC2_DeregisterInstanceEventNotificationAttributes_Call{Call: _e.mock.On("DeregisterInstanceEventNotificationAttributes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeregisterInstanceEventNotificationAttributes_Call) Run(run func(ctx context.Context, params *ec2.DeregisterInstanceEventNotificationAttributesInput, optFns ...func(*ec2.Options))) *EC2_DeregisterInstanceEventNotificationAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeregisterInstanceEventNotificationAttributesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeregisterInstanceEventNotificationAttributes_Call) Return(_a0 *ec2.DeregisterInstanceEventNotificationAttributesOutput, _a1 error) *EC2_DeregisterInstanceEventNotificationAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeregisterInstanceEventNotificationAttributes_Call) RunAndReturn(run func(context.Context, *ec2.DeregisterInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error)) *EC2_DeregisterInstanceEventNotificationAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// DeregisterTransitGatewayMulticastGroupMembers provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeregisterTransitGatewayMulticastGroupMembers(ctx context.Context, params *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, optFns ...func(*ec2.Options)) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeregisterTransitGatewayMulticastGroupMembers")
	}

	var r0 *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, ...func(*ec2.Options)) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, ...func(*ec2.Options)) *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeregisterTransitGatewayMulticastGroupMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeregisterTransitGatewayMulticastGroupMembers'
type EC2_DeregisterTransitGatewayMulticastGroupMembers_Call struct {
	*mock.Call
}

// DeregisterTransitGatewayMulticastGroupMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeregisterTransitGatewayMulticastGroupMembersInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeregisterTransitGatewayMulticastGroupMembers(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeregisterTransitGatewayMulticastGroupMembers_Call {
	return &EC2_DeregisterTransitGatewayMulticastGroupMembers_Call{Call: _e.mock.On("DeregisterTransitGatewayMulticastGroupMembers",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeregisterTransitGatewayMulticastGroupMembers_Call) Run(run func(ctx context.Context, params *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, optFns ...func(*ec2.Options))) *EC2_DeregisterTransitGatewayMulticastGroupMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeregisterTransitGatewayMulticastGroupMembersInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeregisterTransitGatewayMulticastGroupMembers_Call) Return(_a0 *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, _a1 error) *EC2_DeregisterTransitGatewayMulticastGroupMembers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeregisterTransitGatewayMulticastGroupMembers_Call) RunAndReturn(run func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, ...func(*ec2.Options)) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error)) *EC2_DeregisterTransitGatewayMulticastGroupMembers_Call {
	_c.Call.Return(run)
	return _c
}

// DeregisterTransitGatewayMulticastGroupSources provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DeregisterTransitGatewayMulticastGroupSources(ctx context.Context, params *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, optFns ...func(*ec2.Options)) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeregisterTransitGatewayMulticastGroupSources")
	}

	var r0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, ...func(*ec2.Options)) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, ...func(*ec2.Options)) *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DeregisterTransitGatewayMulticastGroupSources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeregisterTransitGatewayMulticastGroupSources'
type EC2_DeregisterTransitGatewayMulticastGroupSources_Call struct {
	*mock.Call
}

// DeregisterTransitGatewayMulticastGroupSources is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DeregisterTransitGatewayMulticastGroupSources(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DeregisterTransitGatewayMulticastGroupSources_Call {
	return &EC2_DeregisterTransitGatewayMulticastGroupSources_Call{Call: _e.mock.On("DeregisterTransitGatewayMulticastGroupSources",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DeregisterTransitGatewayMulticastGroupSources_Call) Run(run func(ctx context.Context, params *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, optFns ...func(*ec2.Options))) *EC2_DeregisterTransitGatewayMulticastGroupSources_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DeregisterTransitGatewayMulticastGroupSources_Call) Return(_a0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, _a1 error) *EC2_DeregisterTransitGatewayMulticastGroupSources_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DeregisterTransitGatewayMulticastGroupSources_Call) RunAndReturn(run func(context.Context, *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, ...func(*ec2.Options)) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error)) *EC2_DeregisterTransitGatewayMulticastGroupSources_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAccountAttributes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeAccountAttributes(ctx context.Context, params *ec2.DescribeAccountAttributesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAccountAttributesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeAccountAttributes")
	}

	var r0 *ec2.DescribeAccountAttributesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAccountAttributesInput, ...func(*ec2.Options)) (*ec2.DescribeAccountAttributesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAccountAttributesInput, ...func(*ec2.Options)) *ec2.DescribeAccountAttributesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAccountAttributesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeAccountAttributesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeAccountAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAccountAttributes'
type EC2_DescribeAccountAttributes_Call struct {
	*mock.Call
}

// DescribeAccountAttributes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeAccountAttributesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeAccountAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeAccountAttributes_Call {
	return &EC2_DescribeAccountAttributes_Call{Call: _e.mock.On("DescribeAccountAttributes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeAccountAttributes_Call) Run(run func(ctx context.Context, params *ec2.DescribeAccountAttributesInput, optFns ...func(*ec2.Options))) *EC2_DescribeAccountAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeAccountAttributesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeAccountAttributes_Call) Return(_a0 *ec2.DescribeAccountAttributesOutput, _a1 error) *EC2_DescribeAccountAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeAccountAttributes_Call) RunAndReturn(run func(context.Context, *ec2.DescribeAccountAttributesInput, ...func(*ec2.Options)) (*ec2.DescribeAccountAttributesOutput, error)) *EC2_DescribeAccountAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAddressTransfers provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeAddressTransfers(ctx context.Context, params *ec2.DescribeAddressTransfersInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAddressTransfersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeAddressTransfers")
	}

	var r0 *ec2.DescribeAddressTransfersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAddressTransfersInput, ...func(*ec2.Options)) (*ec2.DescribeAddressTransfersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAddressTransfersInput, ...func(*ec2.Options)) *ec2.DescribeAddressTransfersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAddressTransfersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeAddressTransfersInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeAddressTransfers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAddressTransfers'
type EC2_DescribeAddressTransfers_Call struct {
	*mock.Call
}

// DescribeAddressTransfers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeAddressTransfersInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeAddressTransfers(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeAddressTransfers_Call {
	return &EC2_DescribeAddressTransfers_Call{Call: _e.mock.On("DescribeAddressTransfers",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeAddressTransfers_Call) Run(run func(ctx context.Context, params *ec2.DescribeAddressTransfersInput, optFns ...func(*ec2.Options))) *EC2_DescribeAddressTransfers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeAddressTransfersInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeAddressTransfers_Call) Return(_a0 *ec2.DescribeAddressTransfersOutput, _a1 error) *EC2_DescribeAddressTransfers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeAddressTransfers_Call) RunAndReturn(run func(context.Context, *ec2.DescribeAddressTransfersInput, ...func(*ec2.Options)) (*ec2.DescribeAddressTransfersOutput, error)) *EC2_DescribeAddressTransfers_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAddresses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeAddresses(ctx context.Context, params *ec2.DescribeAddressesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAddressesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeAddresses")
	}

	var r0 *ec2.DescribeAddressesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAddressesInput, ...func(*ec2.Options)) (*ec2.DescribeAddressesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAddressesInput, ...func(*ec2.Options)) *ec2.DescribeAddressesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAddressesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeAddressesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAddresses'
type EC2_DescribeAddresses_Call struct {
	*mock.Call
}

// DescribeAddresses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeAddressesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeAddresses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeAddresses_Call {
	return &EC2_DescribeAddresses_Call{Call: _e.mock.On("DescribeAddresses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeAddresses_Call) Run(run func(ctx context.Context, params *ec2.DescribeAddressesInput, optFns ...func(*ec2.Options))) *EC2_DescribeAddresses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeAddressesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeAddresses_Call) Return(_a0 *ec2.DescribeAddressesOutput, _a1 error) *EC2_DescribeAddresses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeAddresses_Call) RunAndReturn(run func(context.Context, *ec2.DescribeAddressesInput, ...func(*ec2.Options)) (*ec2.DescribeAddressesOutput, error)) *EC2_DescribeAddresses_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAddressesAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeAddressesAttribute(ctx context.Context, params *ec2.DescribeAddressesAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAddressesAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeAddressesAttribute")
	}

	var r0 *ec2.DescribeAddressesAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAddressesAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeAddressesAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAddressesAttributeInput, ...func(*ec2.Options)) *ec2.DescribeAddressesAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAddressesAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeAddressesAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeAddressesAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAddressesAttribute'
type EC2_DescribeAddressesAttribute_Call struct {
	*mock.Call
}

// DescribeAddressesAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeAddressesAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeAddressesAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeAddressesAttribute_Call {
	return &EC2_DescribeAddressesAttribute_Call{Call: _e.mock.On("DescribeAddressesAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeAddressesAttribute_Call) Run(run func(ctx context.Context, params *ec2.DescribeAddressesAttributeInput, optFns ...func(*ec2.Options))) *EC2_DescribeAddressesAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeAddressesAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeAddressesAttribute_Call) Return(_a0 *ec2.DescribeAddressesAttributeOutput, _a1 error) *EC2_DescribeAddressesAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeAddressesAttribute_Call) RunAndReturn(run func(context.Context, *ec2.DescribeAddressesAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeAddressesAttributeOutput, error)) *EC2_DescribeAddressesAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAggregateIdFormat provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeAggregateIdFormat(ctx context.Context, params *ec2.DescribeAggregateIdFormatInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAggregateIdFormatOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeAggregateIdFormat")
	}

	var r0 *ec2.DescribeAggregateIdFormatOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAggregateIdFormatInput, ...func(*ec2.Options)) (*ec2.DescribeAggregateIdFormatOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAggregateIdFormatInput, ...func(*ec2.Options)) *ec2.DescribeAggregateIdFormatOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAggregateIdFormatOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeAggregateIdFormatInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeAggregateIdFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAggregateIdFormat'
type EC2_DescribeAggregateIdFormat_Call struct {
	*mock.Call
}

// DescribeAggregateIdFormat is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeAggregateIdFormatInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeAggregateIdFormat(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeAggregateIdFormat_Call {
	return &EC2_DescribeAggregateIdFormat_Call{Call: _e.mock.On("DescribeAggregateIdFormat",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeAggregateIdFormat_Call) Run(run func(ctx context.Context, params *ec2.DescribeAggregateIdFormatInput, optFns ...func(*ec2.Options))) *EC2_DescribeAggregateIdFormat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeAggregateIdFormatInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeAggregateIdFormat_Call) Return(_a0 *ec2.DescribeAggregateIdFormatOutput, _a1 error) *EC2_DescribeAggregateIdFormat_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeAggregateIdFormat_Call) RunAndReturn(run func(context.Context, *ec2.DescribeAggregateIdFormatInput, ...func(*ec2.Options)) (*ec2.DescribeAggregateIdFormatOutput, error)) *EC2_DescribeAggregateIdFormat_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAvailabilityZones provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeAvailabilityZones(ctx context.Context, params *ec2.DescribeAvailabilityZonesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAvailabilityZonesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeAvailabilityZones")
	}

	var r0 *ec2.DescribeAvailabilityZonesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAvailabilityZonesInput, ...func(*ec2.Options)) (*ec2.DescribeAvailabilityZonesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAvailabilityZonesInput, ...func(*ec2.Options)) *ec2.DescribeAvailabilityZonesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAvailabilityZonesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeAvailabilityZonesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeAvailabilityZones_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAvailabilityZones'
type EC2_DescribeAvailabilityZones_Call struct {
	*mock.Call
}

// DescribeAvailabilityZones is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeAvailabilityZonesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeAvailabilityZones(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeAvailabilityZones_Call {
	return &EC2_DescribeAvailabilityZones_Call{Call: _e.mock.On("DescribeAvailabilityZones",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeAvailabilityZones_Call) Run(run func(ctx context.Context, params *ec2.DescribeAvailabilityZonesInput, optFns ...func(*ec2.Options))) *EC2_DescribeAvailabilityZones_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeAvailabilityZonesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeAvailabilityZones_Call) Return(_a0 *ec2.DescribeAvailabilityZonesOutput, _a1 error) *EC2_DescribeAvailabilityZones_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeAvailabilityZones_Call) RunAndReturn(run func(context.Context, *ec2.DescribeAvailabilityZonesInput, ...func(*ec2.Options)) (*ec2.DescribeAvailabilityZonesOutput, error)) *EC2_DescribeAvailabilityZones_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAwsNetworkPerformanceMetricSubscriptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeAwsNetworkPerformanceMetricSubscriptions(ctx context.Context, params *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeAwsNetworkPerformanceMetricSubscriptions")
	}

	var r0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, ...func(*ec2.Options)) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, ...func(*ec2.Options)) *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAwsNetworkPerformanceMetricSubscriptions'
type EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call struct {
	*mock.Call
}

// DescribeAwsNetworkPerformanceMetricSubscriptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeAwsNetworkPerformanceMetricSubscriptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call {
	return &EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call{Call: _e.mock.On("DescribeAwsNetworkPerformanceMetricSubscriptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call) Run(run func(ctx context.Context, params *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call) Return(_a0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, _a1 error) *EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, ...func(*ec2.Options)) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error)) *EC2_DescribeAwsNetworkPerformanceMetricSubscriptions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeBundleTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeBundleTasks(ctx context.Context, params *ec2.DescribeBundleTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeBundleTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeBundleTasks")
	}

	var r0 *ec2.DescribeBundleTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeBundleTasksInput, ...func(*ec2.Options)) (*ec2.DescribeBundleTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeBundleTasksInput, ...func(*ec2.Options)) *ec2.DescribeBundleTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeBundleTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeBundleTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeBundleTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeBundleTasks'
type EC2_DescribeBundleTasks_Call struct {
	*mock.Call
}

// DescribeBundleTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeBundleTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeBundleTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeBundleTasks_Call {
	return &EC2_DescribeBundleTasks_Call{Call: _e.mock.On("DescribeBundleTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeBundleTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeBundleTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeBundleTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeBundleTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeBundleTasks_Call) Return(_a0 *ec2.DescribeBundleTasksOutput, _a1 error) *EC2_DescribeBundleTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeBundleTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeBundleTasksInput, ...func(*ec2.Options)) (*ec2.DescribeBundleTasksOutput, error)) *EC2_DescribeBundleTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeByoipCidrs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeByoipCidrs(ctx context.Context, params *ec2.DescribeByoipCidrsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeByoipCidrsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeByoipCidrs")
	}

	var r0 *ec2.DescribeByoipCidrsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeByoipCidrsInput, ...func(*ec2.Options)) (*ec2.DescribeByoipCidrsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeByoipCidrsInput, ...func(*ec2.Options)) *ec2.DescribeByoipCidrsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeByoipCidrsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeByoipCidrsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeByoipCidrs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeByoipCidrs'
type EC2_DescribeByoipCidrs_Call struct {
	*mock.Call
}

// DescribeByoipCidrs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeByoipCidrsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeByoipCidrs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeByoipCidrs_Call {
	return &EC2_DescribeByoipCidrs_Call{Call: _e.mock.On("DescribeByoipCidrs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeByoipCidrs_Call) Run(run func(ctx context.Context, params *ec2.DescribeByoipCidrsInput, optFns ...func(*ec2.Options))) *EC2_DescribeByoipCidrs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeByoipCidrsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeByoipCidrs_Call) Return(_a0 *ec2.DescribeByoipCidrsOutput, _a1 error) *EC2_DescribeByoipCidrs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeByoipCidrs_Call) RunAndReturn(run func(context.Context, *ec2.DescribeByoipCidrsInput, ...func(*ec2.Options)) (*ec2.DescribeByoipCidrsOutput, error)) *EC2_DescribeByoipCidrs_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityBlockExtensionHistory provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityBlockExtensionHistory(ctx context.Context, params *ec2.DescribeCapacityBlockExtensionHistoryInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockExtensionHistoryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityBlockExtensionHistory")
	}

	var r0 *ec2.DescribeCapacityBlockExtensionHistoryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlockExtensionHistoryInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockExtensionHistoryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlockExtensionHistoryInput, ...func(*ec2.Options)) *ec2.DescribeCapacityBlockExtensionHistoryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityBlockExtensionHistoryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityBlockExtensionHistoryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityBlockExtensionHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityBlockExtensionHistory'
type EC2_DescribeCapacityBlockExtensionHistory_Call struct {
	*mock.Call
}

// DescribeCapacityBlockExtensionHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityBlockExtensionHistoryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityBlockExtensionHistory(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityBlockExtensionHistory_Call {
	return &EC2_DescribeCapacityBlockExtensionHistory_Call{Call: _e.mock.On("DescribeCapacityBlockExtensionHistory",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityBlockExtensionHistory_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityBlockExtensionHistoryInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityBlockExtensionHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityBlockExtensionHistoryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityBlockExtensionHistory_Call) Return(_a0 *ec2.DescribeCapacityBlockExtensionHistoryOutput, _a1 error) *EC2_DescribeCapacityBlockExtensionHistory_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityBlockExtensionHistory_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityBlockExtensionHistoryInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockExtensionHistoryOutput, error)) *EC2_DescribeCapacityBlockExtensionHistory_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityBlockExtensionOfferings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityBlockExtensionOfferings(ctx context.Context, params *ec2.DescribeCapacityBlockExtensionOfferingsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockExtensionOfferingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityBlockExtensionOfferings")
	}

	var r0 *ec2.DescribeCapacityBlockExtensionOfferingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlockExtensionOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockExtensionOfferingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlockExtensionOfferingsInput, ...func(*ec2.Options)) *ec2.DescribeCapacityBlockExtensionOfferingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityBlockExtensionOfferingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityBlockExtensionOfferingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityBlockExtensionOfferings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityBlockExtensionOfferings'
type EC2_DescribeCapacityBlockExtensionOfferings_Call struct {
	*mock.Call
}

// DescribeCapacityBlockExtensionOfferings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityBlockExtensionOfferingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityBlockExtensionOfferings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityBlockExtensionOfferings_Call {
	return &EC2_DescribeCapacityBlockExtensionOfferings_Call{Call: _e.mock.On("DescribeCapacityBlockExtensionOfferings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityBlockExtensionOfferings_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityBlockExtensionOfferingsInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityBlockExtensionOfferings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityBlockExtensionOfferingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityBlockExtensionOfferings_Call) Return(_a0 *ec2.DescribeCapacityBlockExtensionOfferingsOutput, _a1 error) *EC2_DescribeCapacityBlockExtensionOfferings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityBlockExtensionOfferings_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityBlockExtensionOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockExtensionOfferingsOutput, error)) *EC2_DescribeCapacityBlockExtensionOfferings_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityBlockOfferings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityBlockOfferings(ctx context.Context, params *ec2.DescribeCapacityBlockOfferingsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockOfferingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityBlockOfferings")
	}

	var r0 *ec2.DescribeCapacityBlockOfferingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlockOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockOfferingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlockOfferingsInput, ...func(*ec2.Options)) *ec2.DescribeCapacityBlockOfferingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityBlockOfferingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityBlockOfferingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityBlockOfferings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityBlockOfferings'
type EC2_DescribeCapacityBlockOfferings_Call struct {
	*mock.Call
}

// DescribeCapacityBlockOfferings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityBlockOfferingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityBlockOfferings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityBlockOfferings_Call {
	return &EC2_DescribeCapacityBlockOfferings_Call{Call: _e.mock.On("DescribeCapacityBlockOfferings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityBlockOfferings_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityBlockOfferingsInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityBlockOfferings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityBlockOfferingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityBlockOfferings_Call) Return(_a0 *ec2.DescribeCapacityBlockOfferingsOutput, _a1 error) *EC2_DescribeCapacityBlockOfferings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityBlockOfferings_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityBlockOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockOfferingsOutput, error)) *EC2_DescribeCapacityBlockOfferings_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityBlockStatus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityBlockStatus(ctx context.Context, params *ec2.DescribeCapacityBlockStatusInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityBlockStatus")
	}

	var r0 *ec2.DescribeCapacityBlockStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlockStatusInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlockStatusInput, ...func(*ec2.Options)) *ec2.DescribeCapacityBlockStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityBlockStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityBlockStatusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityBlockStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityBlockStatus'
type EC2_DescribeCapacityBlockStatus_Call struct {
	*mock.Call
}

// DescribeCapacityBlockStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityBlockStatusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityBlockStatus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityBlockStatus_Call {
	return &EC2_DescribeCapacityBlockStatus_Call{Call: _e.mock.On("DescribeCapacityBlockStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityBlockStatus_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityBlockStatusInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityBlockStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityBlockStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityBlockStatus_Call) Return(_a0 *ec2.DescribeCapacityBlockStatusOutput, _a1 error) *EC2_DescribeCapacityBlockStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityBlockStatus_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityBlockStatusInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlockStatusOutput, error)) *EC2_DescribeCapacityBlockStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityBlocks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityBlocks(ctx context.Context, params *ec2.DescribeCapacityBlocksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityBlocksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityBlocks")
	}

	var r0 *ec2.DescribeCapacityBlocksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlocksInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlocksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityBlocksInput, ...func(*ec2.Options)) *ec2.DescribeCapacityBlocksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityBlocksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityBlocksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityBlocks'
type EC2_DescribeCapacityBlocks_Call struct {
	*mock.Call
}

// DescribeCapacityBlocks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityBlocksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityBlocks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityBlocks_Call {
	return &EC2_DescribeCapacityBlocks_Call{Call: _e.mock.On("DescribeCapacityBlocks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityBlocks_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityBlocksInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityBlocks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityBlocksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityBlocks_Call) Return(_a0 *ec2.DescribeCapacityBlocksOutput, _a1 error) *EC2_DescribeCapacityBlocks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityBlocks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityBlocksInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityBlocksOutput, error)) *EC2_DescribeCapacityBlocks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityManagerDataExports provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityManagerDataExports(ctx context.Context, params *ec2.DescribeCapacityManagerDataExportsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityManagerDataExportsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityManagerDataExports")
	}

	var r0 *ec2.DescribeCapacityManagerDataExportsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityManagerDataExportsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityManagerDataExportsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityManagerDataExportsInput, ...func(*ec2.Options)) *ec2.DescribeCapacityManagerDataExportsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityManagerDataExportsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityManagerDataExportsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityManagerDataExports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityManagerDataExports'
type EC2_DescribeCapacityManagerDataExports_Call struct {
	*mock.Call
}

// DescribeCapacityManagerDataExports is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityManagerDataExportsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityManagerDataExports(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityManagerDataExports_Call {
	return &EC2_DescribeCapacityManagerDataExports_Call{Call: _e.mock.On("DescribeCapacityManagerDataExports",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityManagerDataExports_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityManagerDataExportsInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityManagerDataExports_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityManagerDataExportsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityManagerDataExports_Call) Return(_a0 *ec2.DescribeCapacityManagerDataExportsOutput, _a1 error) *EC2_DescribeCapacityManagerDataExports_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityManagerDataExports_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityManagerDataExportsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityManagerDataExportsOutput, error)) *EC2_DescribeCapacityManagerDataExports_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityReservationBillingRequests provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityReservationBillingRequests(ctx context.Context, params *ec2.DescribeCapacityReservationBillingRequestsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationBillingRequestsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityReservationBillingRequests")
	}

	var r0 *ec2.DescribeCapacityReservationBillingRequestsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationBillingRequestsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationBillingRequestsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationBillingRequestsInput, ...func(*ec2.Options)) *ec2.DescribeCapacityReservationBillingRequestsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityReservationBillingRequestsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityReservationBillingRequestsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityReservationBillingRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityReservationBillingRequests'
type EC2_DescribeCapacityReservationBillingRequests_Call struct {
	*mock.Call
}

// DescribeCapacityReservationBillingRequests is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityReservationBillingRequestsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityReservationBillingRequests(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityReservationBillingRequests_Call {
	return &EC2_DescribeCapacityReservationBillingRequests_Call{Call: _e.mock.On("DescribeCapacityReservationBillingRequests",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityReservationBillingRequests_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityReservationBillingRequestsInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityReservationBillingRequests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityReservationBillingRequestsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityReservationBillingRequests_Call) Return(_a0 *ec2.DescribeCapacityReservationBillingRequestsOutput, _a1 error) *EC2_DescribeCapacityReservationBillingRequests_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityReservationBillingRequests_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityReservationBillingRequestsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationBillingRequestsOutput, error)) *EC2_DescribeCapacityReservationBillingRequests_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityReservationFleets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityReservationFleets(ctx context.Context, params *ec2.DescribeCapacityReservationFleetsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationFleetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityReservationFleets")
	}

	var r0 *ec2.DescribeCapacityReservationFleetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationFleetsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationFleetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationFleetsInput, ...func(*ec2.Options)) *ec2.DescribeCapacityReservationFleetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityReservationFleetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityReservationFleetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityReservationFleets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityReservationFleets'
type EC2_DescribeCapacityReservationFleets_Call struct {
	*mock.Call
}

// DescribeCapacityReservationFleets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityReservationFleetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityReservationFleets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityReservationFleets_Call {
	return &EC2_DescribeCapacityReservationFleets_Call{Call: _e.mock.On("DescribeCapacityReservationFleets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityReservationFleets_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityReservationFleetsInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityReservationFleets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityReservationFleetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityReservationFleets_Call) Return(_a0 *ec2.DescribeCapacityReservationFleetsOutput, _a1 error) *EC2_DescribeCapacityReservationFleets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityReservationFleets_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityReservationFleetsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationFleetsOutput, error)) *EC2_DescribeCapacityReservationFleets_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityReservationTopology provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityReservationTopology(ctx context.Context, params *ec2.DescribeCapacityReservationTopologyInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationTopologyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityReservationTopology")
	}

	var r0 *ec2.DescribeCapacityReservationTopologyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationTopologyInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationTopologyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationTopologyInput, ...func(*ec2.Options)) *ec2.DescribeCapacityReservationTopologyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityReservationTopologyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityReservationTopologyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityReservationTopology_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityReservationTopology'
type EC2_DescribeCapacityReservationTopology_Call struct {
	*mock.Call
}

// DescribeCapacityReservationTopology is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityReservationTopologyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityReservationTopology(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityReservationTopology_Call {
	return &EC2_DescribeCapacityReservationTopology_Call{Call: _e.mock.On("DescribeCapacityReservationTopology",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityReservationTopology_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityReservationTopologyInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityReservationTopology_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityReservationTopologyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityReservationTopology_Call) Return(_a0 *ec2.DescribeCapacityReservationTopologyOutput, _a1 error) *EC2_DescribeCapacityReservationTopology_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityReservationTopology_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityReservationTopologyInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationTopologyOutput, error)) *EC2_DescribeCapacityReservationTopology_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCapacityReservations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCapacityReservations(ctx context.Context, params *ec2.DescribeCapacityReservationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCapacityReservations")
	}

	var r0 *ec2.DescribeCapacityReservationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCapacityReservationsInput, ...func(*ec2.Options)) *ec2.DescribeCapacityReservationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCapacityReservationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCapacityReservationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCapacityReservations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCapacityReservations'
type EC2_DescribeCapacityReservations_Call struct {
	*mock.Call
}

// DescribeCapacityReservations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCapacityReservationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCapacityReservations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCapacityReservations_Call {
	return &EC2_DescribeCapacityReservations_Call{Call: _e.mock.On("DescribeCapacityReservations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCapacityReservations_Call) Run(run func(ctx context.Context, params *ec2.DescribeCapacityReservationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeCapacityReservations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCapacityReservationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCapacityReservations_Call) Return(_a0 *ec2.DescribeCapacityReservationsOutput, _a1 error) *EC2_DescribeCapacityReservations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCapacityReservations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCapacityReservationsInput, ...func(*ec2.Options)) (*ec2.DescribeCapacityReservationsOutput, error)) *EC2_DescribeCapacityReservations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCarrierGateways provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCarrierGateways(ctx context.Context, params *ec2.DescribeCarrierGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCarrierGatewaysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCarrierGateways")
	}

	var r0 *ec2.DescribeCarrierGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCarrierGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeCarrierGatewaysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCarrierGatewaysInput, ...func(*ec2.Options)) *ec2.DescribeCarrierGatewaysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCarrierGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCarrierGatewaysInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCarrierGateways_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCarrierGateways'
type EC2_DescribeCarrierGateways_Call struct {
	*mock.Call
}

// DescribeCarrierGateways is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCarrierGatewaysInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCarrierGateways(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCarrierGateways_Call {
	return &EC2_DescribeCarrierGateways_Call{Call: _e.mock.On("DescribeCarrierGateways",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCarrierGateways_Call) Run(run func(ctx context.Context, params *ec2.DescribeCarrierGatewaysInput, optFns ...func(*ec2.Options))) *EC2_DescribeCarrierGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCarrierGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCarrierGateways_Call) Return(_a0 *ec2.DescribeCarrierGatewaysOutput, _a1 error) *EC2_DescribeCarrierGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCarrierGateways_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCarrierGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeCarrierGatewaysOutput, error)) *EC2_DescribeCarrierGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeClassicLinkInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeClassicLinkInstances(ctx context.Context, params *ec2.DescribeClassicLinkInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeClassicLinkInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeClassicLinkInstances")
	}

	var r0 *ec2.DescribeClassicLinkInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClassicLinkInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeClassicLinkInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClassicLinkInstancesInput, ...func(*ec2.Options)) *ec2.DescribeClassicLinkInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClassicLinkInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeClassicLinkInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeClassicLinkInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeClassicLinkInstances'
type EC2_DescribeClassicLinkInstances_Call struct {
	*mock.Call
}

// DescribeClassicLinkInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeClassicLinkInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeClassicLinkInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeClassicLinkInstances_Call {
	return &EC2_DescribeClassicLinkInstances_Call{Call: _e.mock.On("DescribeClassicLinkInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeClassicLinkInstances_Call) Run(run func(ctx context.Context, params *ec2.DescribeClassicLinkInstancesInput, optFns ...func(*ec2.Options))) *EC2_DescribeClassicLinkInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeClassicLinkInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeClassicLinkInstances_Call) Return(_a0 *ec2.DescribeClassicLinkInstancesOutput, _a1 error) *EC2_DescribeClassicLinkInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeClassicLinkInstances_Call) RunAndReturn(run func(context.Context, *ec2.DescribeClassicLinkInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeClassicLinkInstancesOutput, error)) *EC2_DescribeClassicLinkInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeClientVpnAuthorizationRules provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeClientVpnAuthorizationRules(ctx context.Context, params *ec2.DescribeClientVpnAuthorizationRulesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeClientVpnAuthorizationRules")
	}

	var r0 *ec2.DescribeClientVpnAuthorizationRulesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnAuthorizationRulesInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnAuthorizationRulesInput, ...func(*ec2.Options)) *ec2.DescribeClientVpnAuthorizationRulesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnAuthorizationRulesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeClientVpnAuthorizationRulesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeClientVpnAuthorizationRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeClientVpnAuthorizationRules'
type EC2_DescribeClientVpnAuthorizationRules_Call struct {
	*mock.Call
}

// DescribeClientVpnAuthorizationRules is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeClientVpnAuthorizationRulesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeClientVpnAuthorizationRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeClientVpnAuthorizationRules_Call {
	return &EC2_DescribeClientVpnAuthorizationRules_Call{Call: _e.mock.On("DescribeClientVpnAuthorizationRules",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeClientVpnAuthorizationRules_Call) Run(run func(ctx context.Context, params *ec2.DescribeClientVpnAuthorizationRulesInput, optFns ...func(*ec2.Options))) *EC2_DescribeClientVpnAuthorizationRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeClientVpnAuthorizationRulesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeClientVpnAuthorizationRules_Call) Return(_a0 *ec2.DescribeClientVpnAuthorizationRulesOutput, _a1 error) *EC2_DescribeClientVpnAuthorizationRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeClientVpnAuthorizationRules_Call) RunAndReturn(run func(context.Context, *ec2.DescribeClientVpnAuthorizationRulesInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error)) *EC2_DescribeClientVpnAuthorizationRules_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeClientVpnConnections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeClientVpnConnections(ctx context.Context, params *ec2.DescribeClientVpnConnectionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeClientVpnConnectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeClientVpnConnections")
	}

	var r0 *ec2.DescribeClientVpnConnectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnConnectionsInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnConnectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnConnectionsInput, ...func(*ec2.Options)) *ec2.DescribeClientVpnConnectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnConnectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeClientVpnConnectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeClientVpnConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeClientVpnConnections'
type EC2_DescribeClientVpnConnections_Call struct {
	*mock.Call
}

// DescribeClientVpnConnections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeClientVpnConnectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeClientVpnConnections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeClientVpnConnections_Call {
	return &EC2_DescribeClientVpnConnections_Call{Call: _e.mock.On("DescribeClientVpnConnections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeClientVpnConnections_Call) Run(run func(ctx context.Context, params *ec2.DescribeClientVpnConnectionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeClientVpnConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeClientVpnConnectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeClientVpnConnections_Call) Return(_a0 *ec2.DescribeClientVpnConnectionsOutput, _a1 error) *EC2_DescribeClientVpnConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeClientVpnConnections_Call) RunAndReturn(run func(context.Context, *ec2.DescribeClientVpnConnectionsInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnConnectionsOutput, error)) *EC2_DescribeClientVpnConnections_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeClientVpnEndpoints provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeClientVpnEndpoints(ctx context.Context, params *ec2.DescribeClientVpnEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeClientVpnEndpointsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeClientVpnEndpoints")
	}

	var r0 *ec2.DescribeClientVpnEndpointsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnEndpointsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnEndpointsInput, ...func(*ec2.Options)) *ec2.DescribeClientVpnEndpointsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnEndpointsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeClientVpnEndpointsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeClientVpnEndpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeClientVpnEndpoints'
type EC2_DescribeClientVpnEndpoints_Call struct {
	*mock.Call
}

// DescribeClientVpnEndpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeClientVpnEndpointsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeClientVpnEndpoints(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeClientVpnEndpoints_Call {
	return &EC2_DescribeClientVpnEndpoints_Call{Call: _e.mock.On("DescribeClientVpnEndpoints",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeClientVpnEndpoints_Call) Run(run func(ctx context.Context, params *ec2.DescribeClientVpnEndpointsInput, optFns ...func(*ec2.Options))) *EC2_DescribeClientVpnEndpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeClientVpnEndpointsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeClientVpnEndpoints_Call) Return(_a0 *ec2.DescribeClientVpnEndpointsOutput, _a1 error) *EC2_DescribeClientVpnEndpoints_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeClientVpnEndpoints_Call) RunAndReturn(run func(context.Context, *ec2.DescribeClientVpnEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnEndpointsOutput, error)) *EC2_DescribeClientVpnEndpoints_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeClientVpnRoutes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeClientVpnRoutes(ctx context.Context, params *ec2.DescribeClientVpnRoutesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeClientVpnRoutesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeClientVpnRoutes")
	}

	var r0 *ec2.DescribeClientVpnRoutesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnRoutesInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnRoutesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnRoutesInput, ...func(*ec2.Options)) *ec2.DescribeClientVpnRoutesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnRoutesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeClientVpnRoutesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeClientVpnRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeClientVpnRoutes'
type EC2_DescribeClientVpnRoutes_Call struct {
	*mock.Call
}

// DescribeClientVpnRoutes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeClientVpnRoutesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeClientVpnRoutes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeClientVpnRoutes_Call {
	return &EC2_DescribeClientVpnRoutes_Call{Call: _e.mock.On("DescribeClientVpnRoutes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeClientVpnRoutes_Call) Run(run func(ctx context.Context, params *ec2.DescribeClientVpnRoutesInput, optFns ...func(*ec2.Options))) *EC2_DescribeClientVpnRoutes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeClientVpnRoutesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeClientVpnRoutes_Call) Return(_a0 *ec2.DescribeClientVpnRoutesOutput, _a1 error) *EC2_DescribeClientVpnRoutes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeClientVpnRoutes_Call) RunAndReturn(run func(context.Context, *ec2.DescribeClientVpnRoutesInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnRoutesOutput, error)) *EC2_DescribeClientVpnRoutes_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeClientVpnTargetNetworks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeClientVpnTargetNetworks(ctx context.Context, params *ec2.DescribeClientVpnTargetNetworksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeClientVpnTargetNetworksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeClientVpnTargetNetworks")
	}

	var r0 *ec2.DescribeClientVpnTargetNetworksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnTargetNetworksInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnTargetNetworksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeClientVpnTargetNetworksInput, ...func(*ec2.Options)) *ec2.DescribeClientVpnTargetNetworksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeClientVpnTargetNetworksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeClientVpnTargetNetworksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeClientVpnTargetNetworks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeClientVpnTargetNetworks'
type EC2_DescribeClientVpnTargetNetworks_Call struct {
	*mock.Call
}

// DescribeClientVpnTargetNetworks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeClientVpnTargetNetworksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeClientVpnTargetNetworks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeClientVpnTargetNetworks_Call {
	return &EC2_DescribeClientVpnTargetNetworks_Call{Call: _e.mock.On("DescribeClientVpnTargetNetworks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeClientVpnTargetNetworks_Call) Run(run func(ctx context.Context, params *ec2.DescribeClientVpnTargetNetworksInput, optFns ...func(*ec2.Options))) *EC2_DescribeClientVpnTargetNetworks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeClientVpnTargetNetworksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeClientVpnTargetNetworks_Call) Return(_a0 *ec2.DescribeClientVpnTargetNetworksOutput, _a1 error) *EC2_DescribeClientVpnTargetNetworks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeClientVpnTargetNetworks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeClientVpnTargetNetworksInput, ...func(*ec2.Options)) (*ec2.DescribeClientVpnTargetNetworksOutput, error)) *EC2_DescribeClientVpnTargetNetworks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCoipPools provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCoipPools(ctx context.Context, params *ec2.DescribeCoipPoolsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCoipPoolsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCoipPools")
	}

	var r0 *ec2.DescribeCoipPoolsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCoipPoolsInput, ...func(*ec2.Options)) (*ec2.DescribeCoipPoolsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCoipPoolsInput, ...func(*ec2.Options)) *ec2.DescribeCoipPoolsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCoipPoolsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCoipPoolsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCoipPools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCoipPools'
type EC2_DescribeCoipPools_Call struct {
	*mock.Call
}

// DescribeCoipPools is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCoipPoolsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCoipPools(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCoipPools_Call {
	return &EC2_DescribeCoipPools_Call{Call: _e.mock.On("DescribeCoipPools",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCoipPools_Call) Run(run func(ctx context.Context, params *ec2.DescribeCoipPoolsInput, optFns ...func(*ec2.Options))) *EC2_DescribeCoipPools_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCoipPoolsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCoipPools_Call) Return(_a0 *ec2.DescribeCoipPoolsOutput, _a1 error) *EC2_DescribeCoipPools_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCoipPools_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCoipPoolsInput, ...func(*ec2.Options)) (*ec2.DescribeCoipPoolsOutput, error)) *EC2_DescribeCoipPools_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeConversionTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeConversionTasks(ctx context.Context, params *ec2.DescribeConversionTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeConversionTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeConversionTasks")
	}

	var r0 *ec2.DescribeConversionTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeConversionTasksInput, ...func(*ec2.Options)) (*ec2.DescribeConversionTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeConversionTasksInput, ...func(*ec2.Options)) *ec2.DescribeConversionTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeConversionTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeConversionTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeConversionTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeConversionTasks'
type EC2_DescribeConversionTasks_Call struct {
	*mock.Call
}

// DescribeConversionTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeConversionTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeConversionTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeConversionTasks_Call {
	return &EC2_DescribeConversionTasks_Call{Call: _e.mock.On("DescribeConversionTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeConversionTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeConversionTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeConversionTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeConversionTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeConversionTasks_Call) Return(_a0 *ec2.DescribeConversionTasksOutput, _a1 error) *EC2_DescribeConversionTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeConversionTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeConversionTasksInput, ...func(*ec2.Options)) (*ec2.DescribeConversionTasksOutput, error)) *EC2_DescribeConversionTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeCustomerGateways provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeCustomerGateways(ctx context.Context, params *ec2.DescribeCustomerGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeCustomerGatewaysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeCustomerGateways")
	}

	var r0 *ec2.DescribeCustomerGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCustomerGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeCustomerGatewaysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeCustomerGatewaysInput, ...func(*ec2.Options)) *ec2.DescribeCustomerGatewaysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeCustomerGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeCustomerGatewaysInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeCustomerGateways_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeCustomerGateways'
type EC2_DescribeCustomerGateways_Call struct {
	*mock.Call
}

// DescribeCustomerGateways is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeCustomerGatewaysInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeCustomerGateways(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeCustomerGateways_Call {
	return &EC2_DescribeCustomerGateways_Call{Call: _e.mock.On("DescribeCustomerGateways",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeCustomerGateways_Call) Run(run func(ctx context.Context, params *ec2.DescribeCustomerGatewaysInput, optFns ...func(*ec2.Options))) *EC2_DescribeCustomerGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeCustomerGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeCustomerGateways_Call) Return(_a0 *ec2.DescribeCustomerGatewaysOutput, _a1 error) *EC2_DescribeCustomerGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeCustomerGateways_Call) RunAndReturn(run func(context.Context, *ec2.DescribeCustomerGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeCustomerGatewaysOutput, error)) *EC2_DescribeCustomerGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeDeclarativePoliciesReports provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeDeclarativePoliciesReports(ctx context.Context, params *ec2.DescribeDeclarativePoliciesReportsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeDeclarativePoliciesReportsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeDeclarativePoliciesReports")
	}

	var r0 *ec2.DescribeDeclarativePoliciesReportsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeDeclarativePoliciesReportsInput, ...func(*ec2.Options)) (*ec2.DescribeDeclarativePoliciesReportsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeDeclarativePoliciesReportsInput, ...func(*ec2.Options)) *ec2.DescribeDeclarativePoliciesReportsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeDeclarativePoliciesReportsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeDeclarativePoliciesReportsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeDeclarativePoliciesReports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeDeclarativePoliciesReports'
type EC2_DescribeDeclarativePoliciesReports_Call struct {
	*mock.Call
}

// DescribeDeclarativePoliciesReports is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeDeclarativePoliciesReportsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeDeclarativePoliciesReports(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeDeclarativePoliciesReports_Call {
	return &EC2_DescribeDeclarativePoliciesReports_Call{Call: _e.mock.On("DescribeDeclarativePoliciesReports",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeDeclarativePoliciesReports_Call) Run(run func(ctx context.Context, params *ec2.DescribeDeclarativePoliciesReportsInput, optFns ...func(*ec2.Options))) *EC2_DescribeDeclarativePoliciesReports_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeDeclarativePoliciesReportsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeDeclarativePoliciesReports_Call) Return(_a0 *ec2.DescribeDeclarativePoliciesReportsOutput, _a1 error) *EC2_DescribeDeclarativePoliciesReports_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeDeclarativePoliciesReports_Call) RunAndReturn(run func(context.Context, *ec2.DescribeDeclarativePoliciesReportsInput, ...func(*ec2.Options)) (*ec2.DescribeDeclarativePoliciesReportsOutput, error)) *EC2_DescribeDeclarativePoliciesReports_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeDhcpOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeDhcpOptions(ctx context.Context, params *ec2.DescribeDhcpOptionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeDhcpOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeDhcpOptions")
	}

	var r0 *ec2.DescribeDhcpOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeDhcpOptionsInput, ...func(*ec2.Options)) (*ec2.DescribeDhcpOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeDhcpOptionsInput, ...func(*ec2.Options)) *ec2.DescribeDhcpOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeDhcpOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeDhcpOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeDhcpOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeDhcpOptions'
type EC2_DescribeDhcpOptions_Call struct {
	*mock.Call
}

// DescribeDhcpOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeDhcpOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeDhcpOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeDhcpOptions_Call {
	return &EC2_DescribeDhcpOptions_Call{Call: _e.mock.On("DescribeDhcpOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeDhcpOptions_Call) Run(run func(ctx context.Context, params *ec2.DescribeDhcpOptionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeDhcpOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeDhcpOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeDhcpOptions_Call) Return(_a0 *ec2.DescribeDhcpOptionsOutput, _a1 error) *EC2_DescribeDhcpOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeDhcpOptions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeDhcpOptionsInput, ...func(*ec2.Options)) (*ec2.DescribeDhcpOptionsOutput, error)) *EC2_DescribeDhcpOptions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeEgressOnlyInternetGateways provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeEgressOnlyInternetGateways(ctx context.Context, params *ec2.DescribeEgressOnlyInternetGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeEgressOnlyInternetGateways")
	}

	var r0 *ec2.DescribeEgressOnlyInternetGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeEgressOnlyInternetGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeEgressOnlyInternetGatewaysInput, ...func(*ec2.Options)) *ec2.DescribeEgressOnlyInternetGatewaysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeEgressOnlyInternetGatewaysInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeEgressOnlyInternetGateways_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeEgressOnlyInternetGateways'
type EC2_DescribeEgressOnlyInternetGateways_Call struct {
	*mock.Call
}

// DescribeEgressOnlyInternetGateways is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeEgressOnlyInternetGatewaysInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeEgressOnlyInternetGateways(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeEgressOnlyInternetGateways_Call {
	return &EC2_DescribeEgressOnlyInternetGateways_Call{Call: _e.mock.On("DescribeEgressOnlyInternetGateways",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeEgressOnlyInternetGateways_Call) Run(run func(ctx context.Context, params *ec2.DescribeEgressOnlyInternetGatewaysInput, optFns ...func(*ec2.Options))) *EC2_DescribeEgressOnlyInternetGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeEgressOnlyInternetGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeEgressOnlyInternetGateways_Call) Return(_a0 *ec2.DescribeEgressOnlyInternetGatewaysOutput, _a1 error) *EC2_DescribeEgressOnlyInternetGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeEgressOnlyInternetGateways_Call) RunAndReturn(run func(context.Context, *ec2.DescribeEgressOnlyInternetGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error)) *EC2_DescribeEgressOnlyInternetGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeElasticGpus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeElasticGpus(ctx context.Context, params *ec2.DescribeElasticGpusInput, optFns ...func(*ec2.Options)) (*ec2.DescribeElasticGpusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeElasticGpus")
	}

	var r0 *ec2.DescribeElasticGpusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeElasticGpusInput, ...func(*ec2.Options)) (*ec2.DescribeElasticGpusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeElasticGpusInput, ...func(*ec2.Options)) *ec2.DescribeElasticGpusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeElasticGpusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeElasticGpusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeElasticGpus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeElasticGpus'
type EC2_DescribeElasticGpus_Call struct {
	*mock.Call
}

// DescribeElasticGpus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeElasticGpusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeElasticGpus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeElasticGpus_Call {
	return &EC2_DescribeElasticGpus_Call{Call: _e.mock.On("DescribeElasticGpus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeElasticGpus_Call) Run(run func(ctx context.Context, params *ec2.DescribeElasticGpusInput, optFns ...func(*ec2.Options))) *EC2_DescribeElasticGpus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeElasticGpusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeElasticGpus_Call) Return(_a0 *ec2.DescribeElasticGpusOutput, _a1 error) *EC2_DescribeElasticGpus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeElasticGpus_Call) RunAndReturn(run func(context.Context, *ec2.DescribeElasticGpusInput, ...func(*ec2.Options)) (*ec2.DescribeElasticGpusOutput, error)) *EC2_DescribeElasticGpus_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeExportImageTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeExportImageTasks(ctx context.Context, params *ec2.DescribeExportImageTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeExportImageTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeExportImageTasks")
	}

	var r0 *ec2.DescribeExportImageTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeExportImageTasksInput, ...func(*ec2.Options)) (*ec2.DescribeExportImageTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeExportImageTasksInput, ...func(*ec2.Options)) *ec2.DescribeExportImageTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeExportImageTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeExportImageTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeExportImageTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeExportImageTasks'
type EC2_DescribeExportImageTasks_Call struct {
	*mock.Call
}

// DescribeExportImageTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeExportImageTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeExportImageTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeExportImageTasks_Call {
	return &EC2_DescribeExportImageTasks_Call{Call: _e.mock.On("DescribeExportImageTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeExportImageTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeExportImageTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeExportImageTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeExportImageTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeExportImageTasks_Call) Return(_a0 *ec2.DescribeExportImageTasksOutput, _a1 error) *EC2_DescribeExportImageTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeExportImageTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeExportImageTasksInput, ...func(*ec2.Options)) (*ec2.DescribeExportImageTasksOutput, error)) *EC2_DescribeExportImageTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeExportTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeExportTasks(ctx context.Context, params *ec2.DescribeExportTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeExportTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeExportTasks")
	}

	var r0 *ec2.DescribeExportTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeExportTasksInput, ...func(*ec2.Options)) (*ec2.DescribeExportTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeExportTasksInput, ...func(*ec2.Options)) *ec2.DescribeExportTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeExportTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeExportTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeExportTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeExportTasks'
type EC2_DescribeExportTasks_Call struct {
	*mock.Call
}

// DescribeExportTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeExportTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeExportTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeExportTasks_Call {
	return &EC2_DescribeExportTasks_Call{Call: _e.mock.On("DescribeExportTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeExportTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeExportTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeExportTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeExportTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeExportTasks_Call) Return(_a0 *ec2.DescribeExportTasksOutput, _a1 error) *EC2_DescribeExportTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeExportTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeExportTasksInput, ...func(*ec2.Options)) (*ec2.DescribeExportTasksOutput, error)) *EC2_DescribeExportTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFastLaunchImages provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeFastLaunchImages(ctx context.Context, params *ec2.DescribeFastLaunchImagesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeFastLaunchImagesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeFastLaunchImages")
	}

	var r0 *ec2.DescribeFastLaunchImagesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFastLaunchImagesInput, ...func(*ec2.Options)) (*ec2.DescribeFastLaunchImagesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFastLaunchImagesInput, ...func(*ec2.Options)) *ec2.DescribeFastLaunchImagesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFastLaunchImagesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeFastLaunchImagesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeFastLaunchImages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeFastLaunchImages'
type EC2_DescribeFastLaunchImages_Call struct {
	*mock.Call
}

// DescribeFastLaunchImages is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeFastLaunchImagesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeFastLaunchImages(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeFastLaunchImages_Call {
	return &EC2_DescribeFastLaunchImages_Call{Call: _e.mock.On("DescribeFastLaunchImages",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeFastLaunchImages_Call) Run(run func(ctx context.Context, params *ec2.DescribeFastLaunchImagesInput, optFns ...func(*ec2.Options))) *EC2_DescribeFastLaunchImages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeFastLaunchImagesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeFastLaunchImages_Call) Return(_a0 *ec2.DescribeFastLaunchImagesOutput, _a1 error) *EC2_DescribeFastLaunchImages_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeFastLaunchImages_Call) RunAndReturn(run func(context.Context, *ec2.DescribeFastLaunchImagesInput, ...func(*ec2.Options)) (*ec2.DescribeFastLaunchImagesOutput, error)) *EC2_DescribeFastLaunchImages_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFastSnapshotRestores provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeFastSnapshotRestores(ctx context.Context, params *ec2.DescribeFastSnapshotRestoresInput, optFns ...func(*ec2.Options)) (*ec2.DescribeFastSnapshotRestoresOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeFastSnapshotRestores")
	}

	var r0 *ec2.DescribeFastSnapshotRestoresOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFastSnapshotRestoresInput, ...func(*ec2.Options)) (*ec2.DescribeFastSnapshotRestoresOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFastSnapshotRestoresInput, ...func(*ec2.Options)) *ec2.DescribeFastSnapshotRestoresOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFastSnapshotRestoresOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeFastSnapshotRestoresInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeFastSnapshotRestores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeFastSnapshotRestores'
type EC2_DescribeFastSnapshotRestores_Call struct {
	*mock.Call
}

// DescribeFastSnapshotRestores is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeFastSnapshotRestoresInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeFastSnapshotRestores(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeFastSnapshotRestores_Call {
	return &EC2_DescribeFastSnapshotRestores_Call{Call: _e.mock.On("DescribeFastSnapshotRestores",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeFastSnapshotRestores_Call) Run(run func(ctx context.Context, params *ec2.DescribeFastSnapshotRestoresInput, optFns ...func(*ec2.Options))) *EC2_DescribeFastSnapshotRestores_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeFastSnapshotRestoresInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeFastSnapshotRestores_Call) Return(_a0 *ec2.DescribeFastSnapshotRestoresOutput, _a1 error) *EC2_DescribeFastSnapshotRestores_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeFastSnapshotRestores_Call) RunAndReturn(run func(context.Context, *ec2.DescribeFastSnapshotRestoresInput, ...func(*ec2.Options)) (*ec2.DescribeFastSnapshotRestoresOutput, error)) *EC2_DescribeFastSnapshotRestores_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFleetHistory provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeFleetHistory(ctx context.Context, params *ec2.DescribeFleetHistoryInput, optFns ...func(*ec2.Options)) (*ec2.DescribeFleetHistoryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeFleetHistory")
	}

	var r0 *ec2.DescribeFleetHistoryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetHistoryInput, ...func(*ec2.Options)) (*ec2.DescribeFleetHistoryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetHistoryInput, ...func(*ec2.Options)) *ec2.DescribeFleetHistoryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetHistoryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeFleetHistoryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeFleetHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeFleetHistory'
type EC2_DescribeFleetHistory_Call struct {
	*mock.Call
}

// DescribeFleetHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeFleetHistoryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeFleetHistory(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeFleetHistory_Call {
	return &EC2_DescribeFleetHistory_Call{Call: _e.mock.On("DescribeFleetHistory",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeFleetHistory_Call) Run(run func(ctx context.Context, params *ec2.DescribeFleetHistoryInput, optFns ...func(*ec2.Options))) *EC2_DescribeFleetHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeFleetHistoryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeFleetHistory_Call) Return(_a0 *ec2.DescribeFleetHistoryOutput, _a1 error) *EC2_DescribeFleetHistory_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeFleetHistory_Call) RunAndReturn(run func(context.Context, *ec2.DescribeFleetHistoryInput, ...func(*ec2.Options)) (*ec2.DescribeFleetHistoryOutput, error)) *EC2_DescribeFleetHistory_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFleetInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeFleetInstances(ctx context.Context, params *ec2.DescribeFleetInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeFleetInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeFleetInstances")
	}

	var r0 *ec2.DescribeFleetInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeFleetInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetInstancesInput, ...func(*ec2.Options)) *ec2.DescribeFleetInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeFleetInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeFleetInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeFleetInstances'
type EC2_DescribeFleetInstances_Call struct {
	*mock.Call
}

// DescribeFleetInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeFleetInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeFleetInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeFleetInstances_Call {
	return &EC2_DescribeFleetInstances_Call{Call: _e.mock.On("DescribeFleetInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeFleetInstances_Call) Run(run func(ctx context.Context, params *ec2.DescribeFleetInstancesInput, optFns ...func(*ec2.Options))) *EC2_DescribeFleetInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeFleetInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeFleetInstances_Call) Return(_a0 *ec2.DescribeFleetInstancesOutput, _a1 error) *EC2_DescribeFleetInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeFleetInstances_Call) RunAndReturn(run func(context.Context, *ec2.DescribeFleetInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeFleetInstancesOutput, error)) *EC2_DescribeFleetInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFleets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeFleets(ctx context.Context, params *ec2.DescribeFleetsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeFleetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeFleets")
	}

	var r0 *ec2.DescribeFleetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetsInput, ...func(*ec2.Options)) (*ec2.DescribeFleetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFleetsInput, ...func(*ec2.Options)) *ec2.DescribeFleetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFleetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeFleetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeFleets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeFleets'
type EC2_DescribeFleets_Call struct {
	*mock.Call
}

// DescribeFleets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeFleetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeFleets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeFleets_Call {
	return &EC2_DescribeFleets_Call{Call: _e.mock.On("DescribeFleets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeFleets_Call) Run(run func(ctx context.Context, params *ec2.DescribeFleetsInput, optFns ...func(*ec2.Options))) *EC2_DescribeFleets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeFleetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeFleets_Call) Return(_a0 *ec2.DescribeFleetsOutput, _a1 error) *EC2_DescribeFleets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeFleets_Call) RunAndReturn(run func(context.Context, *ec2.DescribeFleetsInput, ...func(*ec2.Options)) (*ec2.DescribeFleetsOutput, error)) *EC2_DescribeFleets_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFlowLogs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeFlowLogs(ctx context.Context, params *ec2.DescribeFlowLogsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeFlowLogsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeFlowLogs")
	}

	var r0 *ec2.DescribeFlowLogsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFlowLogsInput, ...func(*ec2.Options)) (*ec2.DescribeFlowLogsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFlowLogsInput, ...func(*ec2.Options)) *ec2.DescribeFlowLogsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFlowLogsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeFlowLogsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeFlowLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeFlowLogs'
type EC2_DescribeFlowLogs_Call struct {
	*mock.Call
}

// DescribeFlowLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeFlowLogsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeFlowLogs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeFlowLogs_Call {
	return &EC2_DescribeFlowLogs_Call{Call: _e.mock.On("DescribeFlowLogs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeFlowLogs_Call) Run(run func(ctx context.Context, params *ec2.DescribeFlowLogsInput, optFns ...func(*ec2.Options))) *EC2_DescribeFlowLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeFlowLogsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeFlowLogs_Call) Return(_a0 *ec2.DescribeFlowLogsOutput, _a1 error) *EC2_DescribeFlowLogs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeFlowLogs_Call) RunAndReturn(run func(context.Context, *ec2.DescribeFlowLogsInput, ...func(*ec2.Options)) (*ec2.DescribeFlowLogsOutput, error)) *EC2_DescribeFlowLogs_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFpgaImageAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeFpgaImageAttribute(ctx context.Context, params *ec2.DescribeFpgaImageAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeFpgaImageAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeFpgaImageAttribute")
	}

	var r0 *ec2.DescribeFpgaImageAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFpgaImageAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeFpgaImageAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFpgaImageAttributeInput, ...func(*ec2.Options)) *ec2.DescribeFpgaImageAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFpgaImageAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeFpgaImageAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeFpgaImageAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeFpgaImageAttribute'
type EC2_DescribeFpgaImageAttribute_Call struct {
	*mock.Call
}

// DescribeFpgaImageAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeFpgaImageAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeFpgaImageAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeFpgaImageAttribute_Call {
	return &EC2_DescribeFpgaImageAttribute_Call{Call: _e.mock.On("DescribeFpgaImageAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeFpgaImageAttribute_Call) Run(run func(ctx context.Context, params *ec2.DescribeFpgaImageAttributeInput, optFns ...func(*ec2.Options))) *EC2_DescribeFpgaImageAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeFpgaImageAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeFpgaImageAttribute_Call) Return(_a0 *ec2.DescribeFpgaImageAttributeOutput, _a1 error) *EC2_DescribeFpgaImageAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeFpgaImageAttribute_Call) RunAndReturn(run func(context.Context, *ec2.DescribeFpgaImageAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeFpgaImageAttributeOutput, error)) *EC2_DescribeFpgaImageAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFpgaImages provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeFpgaImages(ctx context.Context, params *ec2.DescribeFpgaImagesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeFpgaImagesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeFpgaImages")
	}

	var r0 *ec2.DescribeFpgaImagesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFpgaImagesInput, ...func(*ec2.Options)) (*ec2.DescribeFpgaImagesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeFpgaImagesInput, ...func(*ec2.Options)) *ec2.DescribeFpgaImagesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeFpgaImagesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeFpgaImagesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeFpgaImages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeFpgaImages'
type EC2_DescribeFpgaImages_Call struct {
	*mock.Call
}

// DescribeFpgaImages is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeFpgaImagesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeFpgaImages(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeFpgaImages_Call {
	return &EC2_DescribeFpgaImages_Call{Call: _e.mock.On("DescribeFpgaImages",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeFpgaImages_Call) Run(run func(ctx context.Context, params *ec2.DescribeFpgaImagesInput, optFns ...func(*ec2.Options))) *EC2_DescribeFpgaImages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeFpgaImagesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeFpgaImages_Call) Return(_a0 *ec2.DescribeFpgaImagesOutput, _a1 error) *EC2_DescribeFpgaImages_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeFpgaImages_Call) RunAndReturn(run func(context.Context, *ec2.DescribeFpgaImagesInput, ...func(*ec2.Options)) (*ec2.DescribeFpgaImagesOutput, error)) *EC2_DescribeFpgaImages_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeHostReservationOfferings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeHostReservationOfferings(ctx context.Context, params *ec2.DescribeHostReservationOfferingsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeHostReservationOfferingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeHostReservationOfferings")
	}

	var r0 *ec2.DescribeHostReservationOfferingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostReservationOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeHostReservationOfferingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostReservationOfferingsInput, ...func(*ec2.Options)) *ec2.DescribeHostReservationOfferingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostReservationOfferingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeHostReservationOfferingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeHostReservationOfferings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeHostReservationOfferings'
type EC2_DescribeHostReservationOfferings_Call struct {
	*mock.Call
}

// DescribeHostReservationOfferings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeHostReservationOfferingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeHostReservationOfferings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeHostReservationOfferings_Call {
	return &EC2_DescribeHostReservationOfferings_Call{Call: _e.mock.On("DescribeHostReservationOfferings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeHostReservationOfferings_Call) Run(run func(ctx context.Context, params *ec2.DescribeHostReservationOfferingsInput, optFns ...func(*ec2.Options))) *EC2_DescribeHostReservationOfferings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeHostReservationOfferingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeHostReservationOfferings_Call) Return(_a0 *ec2.DescribeHostReservationOfferingsOutput, _a1 error) *EC2_DescribeHostReservationOfferings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeHostReservationOfferings_Call) RunAndReturn(run func(context.Context, *ec2.DescribeHostReservationOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeHostReservationOfferingsOutput, error)) *EC2_DescribeHostReservationOfferings_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeHostReservations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeHostReservations(ctx context.Context, params *ec2.DescribeHostReservationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeHostReservationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeHostReservations")
	}

	var r0 *ec2.DescribeHostReservationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostReservationsInput, ...func(*ec2.Options)) (*ec2.DescribeHostReservationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostReservationsInput, ...func(*ec2.Options)) *ec2.DescribeHostReservationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostReservationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeHostReservationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeHostReservations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeHostReservations'
type EC2_DescribeHostReservations_Call struct {
	*mock.Call
}

// DescribeHostReservations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeHostReservationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeHostReservations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeHostReservations_Call {
	return &EC2_DescribeHostReservations_Call{Call: _e.mock.On("DescribeHostReservations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeHostReservations_Call) Run(run func(ctx context.Context, params *ec2.DescribeHostReservationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeHostReservations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeHostReservationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeHostReservations_Call) Return(_a0 *ec2.DescribeHostReservationsOutput, _a1 error) *EC2_DescribeHostReservations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeHostReservations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeHostReservationsInput, ...func(*ec2.Options)) (*ec2.DescribeHostReservationsOutput, error)) *EC2_DescribeHostReservations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeHosts provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeHosts(ctx context.Context, params *ec2.DescribeHostsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeHostsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeHosts")
	}

	var r0 *ec2.DescribeHostsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostsInput, ...func(*ec2.Options)) (*ec2.DescribeHostsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeHostsInput, ...func(*ec2.Options)) *ec2.DescribeHostsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeHostsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeHostsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeHosts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeHosts'
type EC2_DescribeHosts_Call struct {
	*mock.Call
}

// DescribeHosts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeHostsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeHosts(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeHosts_Call {
	return &EC2_DescribeHosts_Call{Call: _e.mock.On("DescribeHosts",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeHosts_Call) Run(run func(ctx context.Context, params *ec2.DescribeHostsInput, optFns ...func(*ec2.Options))) *EC2_DescribeHosts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeHostsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeHosts_Call) Return(_a0 *ec2.DescribeHostsOutput, _a1 error) *EC2_DescribeHosts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeHosts_Call) RunAndReturn(run func(context.Context, *ec2.DescribeHostsInput, ...func(*ec2.Options)) (*ec2.DescribeHostsOutput, error)) *EC2_DescribeHosts_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIamInstanceProfileAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIamInstanceProfileAssociations(ctx context.Context, params *ec2.DescribeIamInstanceProfileAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIamInstanceProfileAssociations")
	}

	var r0 *ec2.DescribeIamInstanceProfileAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIamInstanceProfileAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIamInstanceProfileAssociationsInput, ...func(*ec2.Options)) *ec2.DescribeIamInstanceProfileAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIamInstanceProfileAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIamInstanceProfileAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIamInstanceProfileAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIamInstanceProfileAssociations'
type EC2_DescribeIamInstanceProfileAssociations_Call struct {
	*mock.Call
}

// DescribeIamInstanceProfileAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIamInstanceProfileAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIamInstanceProfileAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIamInstanceProfileAssociations_Call {
	return &EC2_DescribeIamInstanceProfileAssociations_Call{Call: _e.mock.On("DescribeIamInstanceProfileAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIamInstanceProfileAssociations_Call) Run(run func(ctx context.Context, params *ec2.DescribeIamInstanceProfileAssociationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeIamInstanceProfileAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIamInstanceProfileAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIamInstanceProfileAssociations_Call) Return(_a0 *ec2.DescribeIamInstanceProfileAssociationsOutput, _a1 error) *EC2_DescribeIamInstanceProfileAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIamInstanceProfileAssociations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIamInstanceProfileAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error)) *EC2_DescribeIamInstanceProfileAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIdFormat provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIdFormat(ctx context.Context, params *ec2.DescribeIdFormatInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIdFormatOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIdFormat")
	}

	var r0 *ec2.DescribeIdFormatOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIdFormatInput, ...func(*ec2.Options)) (*ec2.DescribeIdFormatOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIdFormatInput, ...func(*ec2.Options)) *ec2.DescribeIdFormatOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIdFormatOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIdFormatInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIdFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIdFormat'
type EC2_DescribeIdFormat_Call struct {
	*mock.Call
}

// DescribeIdFormat is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIdFormatInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIdFormat(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIdFormat_Call {
	return &EC2_DescribeIdFormat_Call{Call: _e.mock.On("DescribeIdFormat",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIdFormat_Call) Run(run func(ctx context.Context, params *ec2.DescribeIdFormatInput, optFns ...func(*ec2.Options))) *EC2_DescribeIdFormat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIdFormatInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIdFormat_Call) Return(_a0 *ec2.DescribeIdFormatOutput, _a1 error) *EC2_DescribeIdFormat_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIdFormat_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIdFormatInput, ...func(*ec2.Options)) (*ec2.DescribeIdFormatOutput, error)) *EC2_DescribeIdFormat_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIdentityIdFormat provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIdentityIdFormat(ctx context.Context, params *ec2.DescribeIdentityIdFormatInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIdentityIdFormatOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIdentityIdFormat")
	}

	var r0 *ec2.DescribeIdentityIdFormatOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIdentityIdFormatInput, ...func(*ec2.Options)) (*ec2.DescribeIdentityIdFormatOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIdentityIdFormatInput, ...func(*ec2.Options)) *ec2.DescribeIdentityIdFormatOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIdentityIdFormatOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIdentityIdFormatInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIdentityIdFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIdentityIdFormat'
type EC2_DescribeIdentityIdFormat_Call struct {
	*mock.Call
}

// DescribeIdentityIdFormat is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIdentityIdFormatInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIdentityIdFormat(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIdentityIdFormat_Call {
	return &EC2_DescribeIdentityIdFormat_Call{Call: _e.mock.On("DescribeIdentityIdFormat",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIdentityIdFormat_Call) Run(run func(ctx context.Context, params *ec2.DescribeIdentityIdFormatInput, optFns ...func(*ec2.Options))) *EC2_DescribeIdentityIdFormat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIdentityIdFormatInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIdentityIdFormat_Call) Return(_a0 *ec2.DescribeIdentityIdFormatOutput, _a1 error) *EC2_DescribeIdentityIdFormat_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIdentityIdFormat_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIdentityIdFormatInput, ...func(*ec2.Options)) (*ec2.DescribeIdentityIdFormatOutput, error)) *EC2_DescribeIdentityIdFormat_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeImageAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeImageAttribute(ctx context.Context, params *ec2.DescribeImageAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImageAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeImageAttribute")
	}

	var r0 *ec2.DescribeImageAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeImageAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageAttributeInput, ...func(*ec2.Options)) *ec2.DescribeImageAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImageAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeImageAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeImageAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeImageAttribute'
type EC2_DescribeImageAttribute_Call struct {
	*mock.Call
}

// DescribeImageAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeImageAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeImageAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeImageAttribute_Call {
	return &EC2_DescribeImageAttribute_Call{Call: _e.mock.On("DescribeImageAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeImageAttribute_Call) Run(run func(ctx context.Context, params *ec2.DescribeImageAttributeInput, optFns ...func(*ec2.Options))) *EC2_DescribeImageAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeImageAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeImageAttribute_Call) Return(_a0 *ec2.DescribeImageAttributeOutput, _a1 error) *EC2_DescribeImageAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeImageAttribute_Call) RunAndReturn(run func(context.Context, *ec2.DescribeImageAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeImageAttributeOutput, error)) *EC2_DescribeImageAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeImageReferences provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeImageReferences(ctx context.Context, params *ec2.DescribeImageReferencesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImageReferencesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeImageReferences")
	}

	var r0 *ec2.DescribeImageReferencesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageReferencesInput, ...func(*ec2.Options)) (*ec2.DescribeImageReferencesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageReferencesInput, ...func(*ec2.Options)) *ec2.DescribeImageReferencesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImageReferencesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeImageReferencesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeImageReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeImageReferences'
type EC2_DescribeImageReferences_Call struct {
	*mock.Call
}

// DescribeImageReferences is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeImageReferencesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeImageReferences(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeImageReferences_Call {
	return &EC2_DescribeImageReferences_Call{Call: _e.mock.On("DescribeImageReferences",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeImageReferences_Call) Run(run func(ctx context.Context, params *ec2.DescribeImageReferencesInput, optFns ...func(*ec2.Options))) *EC2_DescribeImageReferences_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeImageReferencesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeImageReferences_Call) Return(_a0 *ec2.DescribeImageReferencesOutput, _a1 error) *EC2_DescribeImageReferences_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeImageReferences_Call) RunAndReturn(run func(context.Context, *ec2.DescribeImageReferencesInput, ...func(*ec2.Options)) (*ec2.DescribeImageReferencesOutput, error)) *EC2_DescribeImageReferences_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeImageUsageReportEntries provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeImageUsageReportEntries(ctx context.Context, params *ec2.DescribeImageUsageReportEntriesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImageUsageReportEntriesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeImageUsageReportEntries")
	}

	var r0 *ec2.DescribeImageUsageReportEntriesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageUsageReportEntriesInput, ...func(*ec2.Options)) (*ec2.DescribeImageUsageReportEntriesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageUsageReportEntriesInput, ...func(*ec2.Options)) *ec2.DescribeImageUsageReportEntriesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImageUsageReportEntriesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeImageUsageReportEntriesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeImageUsageReportEntries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeImageUsageReportEntries'
type EC2_DescribeImageUsageReportEntries_Call struct {
	*mock.Call
}

// DescribeImageUsageReportEntries is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeImageUsageReportEntriesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeImageUsageReportEntries(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeImageUsageReportEntries_Call {
	return &EC2_DescribeImageUsageReportEntries_Call{Call: _e.mock.On("DescribeImageUsageReportEntries",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeImageUsageReportEntries_Call) Run(run func(ctx context.Context, params *ec2.DescribeImageUsageReportEntriesInput, optFns ...func(*ec2.Options))) *EC2_DescribeImageUsageReportEntries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeImageUsageReportEntriesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeImageUsageReportEntries_Call) Return(_a0 *ec2.DescribeImageUsageReportEntriesOutput, _a1 error) *EC2_DescribeImageUsageReportEntries_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeImageUsageReportEntries_Call) RunAndReturn(run func(context.Context, *ec2.DescribeImageUsageReportEntriesInput, ...func(*ec2.Options)) (*ec2.DescribeImageUsageReportEntriesOutput, error)) *EC2_DescribeImageUsageReportEntries_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeImageUsageReports provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeImageUsageReports(ctx context.Context, params *ec2.DescribeImageUsageReportsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImageUsageReportsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeImageUsageReports")
	}

	var r0 *ec2.DescribeImageUsageReportsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageUsageReportsInput, ...func(*ec2.Options)) (*ec2.DescribeImageUsageReportsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImageUsageReportsInput, ...func(*ec2.Options)) *ec2.DescribeImageUsageReportsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImageUsageReportsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeImageUsageReportsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeImageUsageReports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeImageUsageReports'
type EC2_DescribeImageUsageReports_Call struct {
	*mock.Call
}

// DescribeImageUsageReports is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeImageUsageReportsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeImageUsageReports(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeImageUsageReports_Call {
	return &EC2_DescribeImageUsageReports_Call{Call: _e.mock.On("DescribeImageUsageReports",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeImageUsageReports_Call) Run(run func(ctx context.Context, params *ec2.DescribeImageUsageReportsInput, optFns ...func(*ec2.Options))) *EC2_DescribeImageUsageReports_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeImageUsageReportsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeImageUsageReports_Call) Return(_a0 *ec2.DescribeImageUsageReportsOutput, _a1 error) *EC2_DescribeImageUsageReports_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeImageUsageReports_Call) RunAndReturn(run func(context.Context, *ec2.DescribeImageUsageReportsInput, ...func(*ec2.Options)) (*ec2.DescribeImageUsageReportsOutput, error)) *EC2_DescribeImageUsageReports_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeImages provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeImages(ctx context.Context, params *ec2.DescribeImagesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImagesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeImages")
	}

	var r0 *ec2.DescribeImagesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImagesInput, ...func(*ec2.Options)) (*ec2.DescribeImagesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImagesInput, ...func(*ec2.Options)) *ec2.DescribeImagesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImagesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeImagesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeImages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeImages'
type EC2_DescribeImages_Call struct {
	*mock.Call
}

// DescribeImages is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeImagesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeImages(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeImages_Call {
	return &EC2_DescribeImages_Call{Call: _e.mock.On("DescribeImages",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeImages_Call) Run(run func(ctx context.Context, params *ec2.DescribeImagesInput, optFns ...func(*ec2.Options))) *EC2_DescribeImages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeImagesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeImages_Call) Return(_a0 *ec2.DescribeImagesOutput, _a1 error) *EC2_DescribeImages_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeImages_Call) RunAndReturn(run func(context.Context, *ec2.DescribeImagesInput, ...func(*ec2.Options)) (*ec2.DescribeImagesOutput, error)) *EC2_DescribeImages_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeImportImageTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeImportImageTasks(ctx context.Context, params *ec2.DescribeImportImageTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImportImageTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeImportImageTasks")
	}

	var r0 *ec2.DescribeImportImageTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImportImageTasksInput, ...func(*ec2.Options)) (*ec2.DescribeImportImageTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImportImageTasksInput, ...func(*ec2.Options)) *ec2.DescribeImportImageTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImportImageTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeImportImageTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeImportImageTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeImportImageTasks'
type EC2_DescribeImportImageTasks_Call struct {
	*mock.Call
}

// DescribeImportImageTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeImportImageTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeImportImageTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeImportImageTasks_Call {
	return &EC2_DescribeImportImageTasks_Call{Call: _e.mock.On("DescribeImportImageTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeImportImageTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeImportImageTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeImportImageTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeImportImageTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeImportImageTasks_Call) Return(_a0 *ec2.DescribeImportImageTasksOutput, _a1 error) *EC2_DescribeImportImageTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeImportImageTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeImportImageTasksInput, ...func(*ec2.Options)) (*ec2.DescribeImportImageTasksOutput, error)) *EC2_DescribeImportImageTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeImportSnapshotTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeImportSnapshotTasks(ctx context.Context, params *ec2.DescribeImportSnapshotTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeImportSnapshotTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeImportSnapshotTasks")
	}

	var r0 *ec2.DescribeImportSnapshotTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImportSnapshotTasksInput, ...func(*ec2.Options)) (*ec2.DescribeImportSnapshotTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeImportSnapshotTasksInput, ...func(*ec2.Options)) *ec2.DescribeImportSnapshotTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeImportSnapshotTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeImportSnapshotTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeImportSnapshotTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeImportSnapshotTasks'
type EC2_DescribeImportSnapshotTasks_Call struct {
	*mock.Call
}

// DescribeImportSnapshotTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeImportSnapshotTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeImportSnapshotTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeImportSnapshotTasks_Call {
	return &EC2_DescribeImportSnapshotTasks_Call{Call: _e.mock.On("DescribeImportSnapshotTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeImportSnapshotTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeImportSnapshotTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeImportSnapshotTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeImportSnapshotTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeImportSnapshotTasks_Call) Return(_a0 *ec2.DescribeImportSnapshotTasksOutput, _a1 error) *EC2_DescribeImportSnapshotTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeImportSnapshotTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeImportSnapshotTasksInput, ...func(*ec2.Options)) (*ec2.DescribeImportSnapshotTasksOutput, error)) *EC2_DescribeImportSnapshotTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceAttribute(ctx context.Context, params *ec2.DescribeInstanceAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceAttribute")
	}

	var r0 *ec2.DescribeInstanceAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceAttributeInput, ...func(*ec2.Options)) *ec2.DescribeInstanceAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceAttribute'
type EC2_DescribeInstanceAttribute_Call struct {
	*mock.Call
}

// DescribeInstanceAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceAttribute_Call {
	return &EC2_DescribeInstanceAttribute_Call{Call: _e.mock.On("DescribeInstanceAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceAttribute_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceAttributeInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceAttribute_Call) Return(_a0 *ec2.DescribeInstanceAttributeOutput, _a1 error) *EC2_DescribeInstanceAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceAttribute_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceAttributeOutput, error)) *EC2_DescribeInstanceAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceConnectEndpoints provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceConnectEndpoints(ctx context.Context, params *ec2.DescribeInstanceConnectEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceConnectEndpointsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceConnectEndpoints")
	}

	var r0 *ec2.DescribeInstanceConnectEndpointsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceConnectEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceConnectEndpointsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceConnectEndpointsInput, ...func(*ec2.Options)) *ec2.DescribeInstanceConnectEndpointsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceConnectEndpointsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceConnectEndpointsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceConnectEndpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceConnectEndpoints'
type EC2_DescribeInstanceConnectEndpoints_Call struct {
	*mock.Call
}

// DescribeInstanceConnectEndpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceConnectEndpointsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceConnectEndpoints(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceConnectEndpoints_Call {
	return &EC2_DescribeInstanceConnectEndpoints_Call{Call: _e.mock.On("DescribeInstanceConnectEndpoints",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceConnectEndpoints_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceConnectEndpointsInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceConnectEndpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceConnectEndpointsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceConnectEndpoints_Call) Return(_a0 *ec2.DescribeInstanceConnectEndpointsOutput, _a1 error) *EC2_DescribeInstanceConnectEndpoints_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceConnectEndpoints_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceConnectEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceConnectEndpointsOutput, error)) *EC2_DescribeInstanceConnectEndpoints_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceCreditSpecifications provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceCreditSpecifications(ctx context.Context, params *ec2.DescribeInstanceCreditSpecificationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceCreditSpecifications")
	}

	var r0 *ec2.DescribeInstanceCreditSpecificationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceCreditSpecificationsInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceCreditSpecificationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceCreditSpecificationsInput, ...func(*ec2.Options)) *ec2.DescribeInstanceCreditSpecificationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceCreditSpecificationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceCreditSpecificationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceCreditSpecifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceCreditSpecifications'
type EC2_DescribeInstanceCreditSpecifications_Call struct {
	*mock.Call
}

// DescribeInstanceCreditSpecifications is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceCreditSpecificationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceCreditSpecifications(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceCreditSpecifications_Call {
	return &EC2_DescribeInstanceCreditSpecifications_Call{Call: _e.mock.On("DescribeInstanceCreditSpecifications",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceCreditSpecifications_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceCreditSpecificationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceCreditSpecifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceCreditSpecificationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceCreditSpecifications_Call) Return(_a0 *ec2.DescribeInstanceCreditSpecificationsOutput, _a1 error) *EC2_DescribeInstanceCreditSpecifications_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceCreditSpecifications_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceCreditSpecificationsInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceCreditSpecificationsOutput, error)) *EC2_DescribeInstanceCreditSpecifications_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceEventNotificationAttributes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceEventNotificationAttributes(ctx context.Context, params *ec2.DescribeInstanceEventNotificationAttributesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceEventNotificationAttributes")
	}

	var r0 *ec2.DescribeInstanceEventNotificationAttributesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) *ec2.DescribeInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceEventNotificationAttributesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceEventNotificationAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceEventNotificationAttributes'
type EC2_DescribeInstanceEventNotificationAttributes_Call struct {
	*mock.Call
}

// DescribeInstanceEventNotificationAttributes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceEventNotificationAttributesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceEventNotificationAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceEventNotificationAttributes_Call {
	return &EC2_DescribeInstanceEventNotificationAttributes_Call{Call: _e.mock.On("DescribeInstanceEventNotificationAttributes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceEventNotificationAttributes_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceEventNotificationAttributesInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceEventNotificationAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceEventNotificationAttributesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceEventNotificationAttributes_Call) Return(_a0 *ec2.DescribeInstanceEventNotificationAttributesOutput, _a1 error) *EC2_DescribeInstanceEventNotificationAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceEventNotificationAttributes_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error)) *EC2_DescribeInstanceEventNotificationAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceEventWindows provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceEventWindows(ctx context.Context, params *ec2.DescribeInstanceEventWindowsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceEventWindowsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceEventWindows")
	}

	var r0 *ec2.DescribeInstanceEventWindowsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceEventWindowsInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceEventWindowsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceEventWindowsInput, ...func(*ec2.Options)) *ec2.DescribeInstanceEventWindowsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceEventWindowsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceEventWindowsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceEventWindows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceEventWindows'
type EC2_DescribeInstanceEventWindows_Call struct {
	*mock.Call
}

// DescribeInstanceEventWindows is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceEventWindowsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceEventWindows(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceEventWindows_Call {
	return &EC2_DescribeInstanceEventWindows_Call{Call: _e.mock.On("DescribeInstanceEventWindows",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceEventWindows_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceEventWindowsInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceEventWindows_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceEventWindowsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceEventWindows_Call) Return(_a0 *ec2.DescribeInstanceEventWindowsOutput, _a1 error) *EC2_DescribeInstanceEventWindows_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceEventWindows_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceEventWindowsInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceEventWindowsOutput, error)) *EC2_DescribeInstanceEventWindows_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceImageMetadata provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceImageMetadata(ctx context.Context, params *ec2.DescribeInstanceImageMetadataInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceImageMetadataOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceImageMetadata")
	}

	var r0 *ec2.DescribeInstanceImageMetadataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceImageMetadataInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceImageMetadataOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceImageMetadataInput, ...func(*ec2.Options)) *ec2.DescribeInstanceImageMetadataOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceImageMetadataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceImageMetadataInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceImageMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceImageMetadata'
type EC2_DescribeInstanceImageMetadata_Call struct {
	*mock.Call
}

// DescribeInstanceImageMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceImageMetadataInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceImageMetadata(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceImageMetadata_Call {
	return &EC2_DescribeInstanceImageMetadata_Call{Call: _e.mock.On("DescribeInstanceImageMetadata",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceImageMetadata_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceImageMetadataInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceImageMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceImageMetadataInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceImageMetadata_Call) Return(_a0 *ec2.DescribeInstanceImageMetadataOutput, _a1 error) *EC2_DescribeInstanceImageMetadata_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceImageMetadata_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceImageMetadataInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceImageMetadataOutput, error)) *EC2_DescribeInstanceImageMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceSqlHaHistoryStates provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceSqlHaHistoryStates(ctx context.Context, params *ec2.DescribeInstanceSqlHaHistoryStatesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaHistoryStatesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceSqlHaHistoryStates")
	}

	var r0 *ec2.DescribeInstanceSqlHaHistoryStatesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceSqlHaHistoryStatesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaHistoryStatesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceSqlHaHistoryStatesInput, ...func(*ec2.Options)) *ec2.DescribeInstanceSqlHaHistoryStatesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceSqlHaHistoryStatesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceSqlHaHistoryStatesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceSqlHaHistoryStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceSqlHaHistoryStates'
type EC2_DescribeInstanceSqlHaHistoryStates_Call struct {
	*mock.Call
}

// DescribeInstanceSqlHaHistoryStates is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceSqlHaHistoryStatesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceSqlHaHistoryStates(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceSqlHaHistoryStates_Call {
	return &EC2_DescribeInstanceSqlHaHistoryStates_Call{Call: _e.mock.On("DescribeInstanceSqlHaHistoryStates",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceSqlHaHistoryStates_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceSqlHaHistoryStatesInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceSqlHaHistoryStates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceSqlHaHistoryStatesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceSqlHaHistoryStates_Call) Return(_a0 *ec2.DescribeInstanceSqlHaHistoryStatesOutput, _a1 error) *EC2_DescribeInstanceSqlHaHistoryStates_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceSqlHaHistoryStates_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceSqlHaHistoryStatesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaHistoryStatesOutput, error)) *EC2_DescribeInstanceSqlHaHistoryStates_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceSqlHaStates provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceSqlHaStates(ctx context.Context, params *ec2.DescribeInstanceSqlHaStatesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaStatesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceSqlHaStates")
	}

	var r0 *ec2.DescribeInstanceSqlHaStatesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceSqlHaStatesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaStatesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceSqlHaStatesInput, ...func(*ec2.Options)) *ec2.DescribeInstanceSqlHaStatesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceSqlHaStatesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceSqlHaStatesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceSqlHaStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceSqlHaStates'
type EC2_DescribeInstanceSqlHaStates_Call struct {
	*mock.Call
}

// DescribeInstanceSqlHaStates is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceSqlHaStatesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceSqlHaStates(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceSqlHaStates_Call {
	return &EC2_DescribeInstanceSqlHaStates_Call{Call: _e.mock.On("DescribeInstanceSqlHaStates",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceSqlHaStates_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceSqlHaStatesInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceSqlHaStates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceSqlHaStatesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceSqlHaStates_Call) Return(_a0 *ec2.DescribeInstanceSqlHaStatesOutput, _a1 error) *EC2_DescribeInstanceSqlHaStates_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceSqlHaStates_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceSqlHaStatesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceSqlHaStatesOutput, error)) *EC2_DescribeInstanceSqlHaStates_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceStatus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceStatus(ctx context.Context, params *ec2.DescribeInstanceStatusInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceStatus")
	}

	var r0 *ec2.DescribeInstanceStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceStatusInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceStatusInput, ...func(*ec2.Options)) *ec2.DescribeInstanceStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceStatusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceStatus'
type EC2_DescribeInstanceStatus_Call struct {
	*mock.Call
}

// DescribeInstanceStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceStatusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceStatus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceStatus_Call {
	return &EC2_DescribeInstanceStatus_Call{Call: _e.mock.On("DescribeInstanceStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceStatus_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceStatusInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceStatus_Call) Return(_a0 *ec2.DescribeInstanceStatusOutput, _a1 error) *EC2_DescribeInstanceStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceStatus_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceStatusInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceStatusOutput, error)) *EC2_DescribeInstanceStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceTopology provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceTopology(ctx context.Context, params *ec2.DescribeInstanceTopologyInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceTopologyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceTopology")
	}

	var r0 *ec2.DescribeInstanceTopologyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceTopologyInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceTopologyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceTopologyInput, ...func(*ec2.Options)) *ec2.DescribeInstanceTopologyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceTopologyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceTopologyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceTopology_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceTopology'
type EC2_DescribeInstanceTopology_Call struct {
	*mock.Call
}

// DescribeInstanceTopology is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceTopologyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceTopology(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceTopology_Call {
	return &EC2_DescribeInstanceTopology_Call{Call: _e.mock.On("DescribeInstanceTopology",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceTopology_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceTopologyInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceTopology_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceTopologyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceTopology_Call) Return(_a0 *ec2.DescribeInstanceTopologyOutput, _a1 error) *EC2_DescribeInstanceTopology_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceTopology_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceTopologyInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceTopologyOutput, error)) *EC2_DescribeInstanceTopology_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceTypeOfferings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceTypeOfferings(ctx context.Context, params *ec2.DescribeInstanceTypeOfferingsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceTypeOfferingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceTypeOfferings")
	}

	var r0 *ec2.DescribeInstanceTypeOfferingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceTypeOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceTypeOfferingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceTypeOfferingsInput, ...func(*ec2.Options)) *ec2.DescribeInstanceTypeOfferingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceTypeOfferingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceTypeOfferingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceTypeOfferings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceTypeOfferings'
type EC2_DescribeInstanceTypeOfferings_Call struct {
	*mock.Call
}

// DescribeInstanceTypeOfferings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceTypeOfferingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceTypeOfferings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceTypeOfferings_Call {
	return &EC2_DescribeInstanceTypeOfferings_Call{Call: _e.mock.On("DescribeInstanceTypeOfferings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceTypeOfferings_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceTypeOfferingsInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceTypeOfferings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceTypeOfferingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceTypeOfferings_Call) Return(_a0 *ec2.DescribeInstanceTypeOfferingsOutput, _a1 error) *EC2_DescribeInstanceTypeOfferings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceTypeOfferings_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceTypeOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceTypeOfferingsOutput, error)) *EC2_DescribeInstanceTypeOfferings_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstanceTypes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstanceTypes(ctx context.Context, params *ec2.DescribeInstanceTypesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceTypesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstanceTypes")
	}

	var r0 *ec2.DescribeInstanceTypesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceTypesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceTypesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstanceTypesInput, ...func(*ec2.Options)) *ec2.DescribeInstanceTypesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstanceTypesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstanceTypesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstanceTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstanceTypes'
type EC2_DescribeInstanceTypes_Call struct {
	*mock.Call
}

// DescribeInstanceTypes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstanceTypesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstanceTypes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstanceTypes_Call {
	return &EC2_DescribeInstanceTypes_Call{Call: _e.mock.On("DescribeInstanceTypes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstanceTypes_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstanceTypesInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstanceTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstanceTypesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstanceTypes_Call) Return(_a0 *ec2.DescribeInstanceTypesOutput, _a1 error) *EC2_DescribeInstanceTypes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstanceTypes_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstanceTypesInput, ...func(*ec2.Options)) (*ec2.DescribeInstanceTypesOutput, error)) *EC2_DescribeInstanceTypes_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInstances(ctx context.Context, params *ec2.DescribeInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInstances")
	}

	var r0 *ec2.DescribeInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInstancesInput, ...func(*ec2.Options)) *ec2.DescribeInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInstances'
type EC2_DescribeInstances_Call struct {
	*mock.Call
}

// DescribeInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInstances_Call {
	return &EC2_DescribeInstances_Call{Call: _e.mock.On("DescribeInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInstances_Call) Run(run func(ctx context.Context, params *ec2.DescribeInstancesInput, optFns ...func(*ec2.Options))) *EC2_DescribeInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInstances_Call) Return(_a0 *ec2.DescribeInstancesOutput, _a1 error) *EC2_DescribeInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInstances_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeInstancesOutput, error)) *EC2_DescribeInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInternetGateways provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeInternetGateways(ctx context.Context, params *ec2.DescribeInternetGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInternetGatewaysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeInternetGateways")
	}

	var r0 *ec2.DescribeInternetGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInternetGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeInternetGatewaysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeInternetGatewaysInput, ...func(*ec2.Options)) *ec2.DescribeInternetGatewaysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeInternetGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeInternetGatewaysInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeInternetGateways_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeInternetGateways'
type EC2_DescribeInternetGateways_Call struct {
	*mock.Call
}

// DescribeInternetGateways is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeInternetGatewaysInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeInternetGateways(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeInternetGateways_Call {
	return &EC2_DescribeInternetGateways_Call{Call: _e.mock.On("DescribeInternetGateways",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeInternetGateways_Call) Run(run func(ctx context.Context, params *ec2.DescribeInternetGatewaysInput, optFns ...func(*ec2.Options))) *EC2_DescribeInternetGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeInternetGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeInternetGateways_Call) Return(_a0 *ec2.DescribeInternetGatewaysOutput, _a1 error) *EC2_DescribeInternetGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeInternetGateways_Call) RunAndReturn(run func(context.Context, *ec2.DescribeInternetGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeInternetGatewaysOutput, error)) *EC2_DescribeInternetGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamByoasn provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamByoasn(ctx context.Context, params *ec2.DescribeIpamByoasnInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamByoasnOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamByoasn")
	}

	var r0 *ec2.DescribeIpamByoasnOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamByoasnInput, ...func(*ec2.Options)) (*ec2.DescribeIpamByoasnOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamByoasnInput, ...func(*ec2.Options)) *ec2.DescribeIpamByoasnOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamByoasnOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamByoasnInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamByoasn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamByoasn'
type EC2_DescribeIpamByoasn_Call struct {
	*mock.Call
}

// DescribeIpamByoasn is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamByoasnInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamByoasn(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamByoasn_Call {
	return &EC2_DescribeIpamByoasn_Call{Call: _e.mock.On("DescribeIpamByoasn",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamByoasn_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamByoasnInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamByoasn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamByoasnInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamByoasn_Call) Return(_a0 *ec2.DescribeIpamByoasnOutput, _a1 error) *EC2_DescribeIpamByoasn_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamByoasn_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamByoasnInput, ...func(*ec2.Options)) (*ec2.DescribeIpamByoasnOutput, error)) *EC2_DescribeIpamByoasn_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamExternalResourceVerificationTokens provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamExternalResourceVerificationTokens(ctx context.Context, params *ec2.DescribeIpamExternalResourceVerificationTokensInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamExternalResourceVerificationTokensOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamExternalResourceVerificationTokens")
	}

	var r0 *ec2.DescribeIpamExternalResourceVerificationTokensOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamExternalResourceVerificationTokensInput, ...func(*ec2.Options)) (*ec2.DescribeIpamExternalResourceVerificationTokensOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamExternalResourceVerificationTokensInput, ...func(*ec2.Options)) *ec2.DescribeIpamExternalResourceVerificationTokensOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamExternalResourceVerificationTokensOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamExternalResourceVerificationTokensInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamExternalResourceVerificationTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamExternalResourceVerificationTokens'
type EC2_DescribeIpamExternalResourceVerificationTokens_Call struct {
	*mock.Call
}

// DescribeIpamExternalResourceVerificationTokens is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamExternalResourceVerificationTokensInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamExternalResourceVerificationTokens(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamExternalResourceVerificationTokens_Call {
	return &EC2_DescribeIpamExternalResourceVerificationTokens_Call{Call: _e.mock.On("DescribeIpamExternalResourceVerificationTokens",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamExternalResourceVerificationTokens_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamExternalResourceVerificationTokensInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamExternalResourceVerificationTokens_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamExternalResourceVerificationTokensInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamExternalResourceVerificationTokens_Call) Return(_a0 *ec2.DescribeIpamExternalResourceVerificationTokensOutput, _a1 error) *EC2_DescribeIpamExternalResourceVerificationTokens_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamExternalResourceVerificationTokens_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamExternalResourceVerificationTokensInput, ...func(*ec2.Options)) (*ec2.DescribeIpamExternalResourceVerificationTokensOutput, error)) *EC2_DescribeIpamExternalResourceVerificationTokens_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamPolicies provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamPolicies(ctx context.Context, params *ec2.DescribeIpamPoliciesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamPoliciesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamPolicies")
	}

	var r0 *ec2.DescribeIpamPoliciesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPoliciesInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPoliciesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPoliciesInput, ...func(*ec2.Options)) *ec2.DescribeIpamPoliciesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamPoliciesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamPoliciesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamPolicies'
type EC2_DescribeIpamPolicies_Call struct {
	*mock.Call
}

// DescribeIpamPolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamPoliciesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamPolicies(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamPolicies_Call {
	return &EC2_DescribeIpamPolicies_Call{Call: _e.mock.On("DescribeIpamPolicies",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamPolicies_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamPoliciesInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamPoliciesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamPolicies_Call) Return(_a0 *ec2.DescribeIpamPoliciesOutput, _a1 error) *EC2_DescribeIpamPolicies_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamPolicies_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamPoliciesInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPoliciesOutput, error)) *EC2_DescribeIpamPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamPools provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamPools(ctx context.Context, params *ec2.DescribeIpamPoolsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamPoolsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamPools")
	}

	var r0 *ec2.DescribeIpamPoolsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPoolsInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPoolsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPoolsInput, ...func(*ec2.Options)) *ec2.DescribeIpamPoolsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamPoolsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamPoolsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamPools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamPools'
type EC2_DescribeIpamPools_Call struct {
	*mock.Call
}

// DescribeIpamPools is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamPoolsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamPools(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamPools_Call {
	return &EC2_DescribeIpamPools_Call{Call: _e.mock.On("DescribeIpamPools",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamPools_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamPoolsInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamPools_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamPoolsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamPools_Call) Return(_a0 *ec2.DescribeIpamPoolsOutput, _a1 error) *EC2_DescribeIpamPools_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamPools_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamPoolsInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPoolsOutput, error)) *EC2_DescribeIpamPools_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamPrefixListResolverTargets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamPrefixListResolverTargets(ctx context.Context, params *ec2.DescribeIpamPrefixListResolverTargetsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamPrefixListResolverTargetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamPrefixListResolverTargets")
	}

	var r0 *ec2.DescribeIpamPrefixListResolverTargetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPrefixListResolverTargetsInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPrefixListResolverTargetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPrefixListResolverTargetsInput, ...func(*ec2.Options)) *ec2.DescribeIpamPrefixListResolverTargetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamPrefixListResolverTargetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamPrefixListResolverTargetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamPrefixListResolverTargets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamPrefixListResolverTargets'
type EC2_DescribeIpamPrefixListResolverTargets_Call struct {
	*mock.Call
}

// DescribeIpamPrefixListResolverTargets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamPrefixListResolverTargetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamPrefixListResolverTargets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamPrefixListResolverTargets_Call {
	return &EC2_DescribeIpamPrefixListResolverTargets_Call{Call: _e.mock.On("DescribeIpamPrefixListResolverTargets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamPrefixListResolverTargets_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamPrefixListResolverTargetsInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamPrefixListResolverTargets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamPrefixListResolverTargetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamPrefixListResolverTargets_Call) Return(_a0 *ec2.DescribeIpamPrefixListResolverTargetsOutput, _a1 error) *EC2_DescribeIpamPrefixListResolverTargets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamPrefixListResolverTargets_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamPrefixListResolverTargetsInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPrefixListResolverTargetsOutput, error)) *EC2_DescribeIpamPrefixListResolverTargets_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamPrefixListResolvers provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamPrefixListResolvers(ctx context.Context, params *ec2.DescribeIpamPrefixListResolversInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamPrefixListResolversOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamPrefixListResolvers")
	}

	var r0 *ec2.DescribeIpamPrefixListResolversOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPrefixListResolversInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPrefixListResolversOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamPrefixListResolversInput, ...func(*ec2.Options)) *ec2.DescribeIpamPrefixListResolversOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamPrefixListResolversOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamPrefixListResolversInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamPrefixListResolvers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamPrefixListResolvers'
type EC2_DescribeIpamPrefixListResolvers_Call struct {
	*mock.Call
}

// DescribeIpamPrefixListResolvers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamPrefixListResolversInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamPrefixListResolvers(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamPrefixListResolvers_Call {
	return &EC2_DescribeIpamPrefixListResolvers_Call{Call: _e.mock.On("DescribeIpamPrefixListResolvers",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamPrefixListResolvers_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamPrefixListResolversInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamPrefixListResolvers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamPrefixListResolversInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamPrefixListResolvers_Call) Return(_a0 *ec2.DescribeIpamPrefixListResolversOutput, _a1 error) *EC2_DescribeIpamPrefixListResolvers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamPrefixListResolvers_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamPrefixListResolversInput, ...func(*ec2.Options)) (*ec2.DescribeIpamPrefixListResolversOutput, error)) *EC2_DescribeIpamPrefixListResolvers_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamResourceDiscoveries provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamResourceDiscoveries(ctx context.Context, params *ec2.DescribeIpamResourceDiscoveriesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamResourceDiscoveriesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamResourceDiscoveries")
	}

	var r0 *ec2.DescribeIpamResourceDiscoveriesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamResourceDiscoveriesInput, ...func(*ec2.Options)) (*ec2.DescribeIpamResourceDiscoveriesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamResourceDiscoveriesInput, ...func(*ec2.Options)) *ec2.DescribeIpamResourceDiscoveriesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamResourceDiscoveriesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamResourceDiscoveriesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamResourceDiscoveries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamResourceDiscoveries'
type EC2_DescribeIpamResourceDiscoveries_Call struct {
	*mock.Call
}

// DescribeIpamResourceDiscoveries is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamResourceDiscoveriesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamResourceDiscoveries(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamResourceDiscoveries_Call {
	return &EC2_DescribeIpamResourceDiscoveries_Call{Call: _e.mock.On("DescribeIpamResourceDiscoveries",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamResourceDiscoveries_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamResourceDiscoveriesInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamResourceDiscoveries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamResourceDiscoveriesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamResourceDiscoveries_Call) Return(_a0 *ec2.DescribeIpamResourceDiscoveriesOutput, _a1 error) *EC2_DescribeIpamResourceDiscoveries_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamResourceDiscoveries_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamResourceDiscoveriesInput, ...func(*ec2.Options)) (*ec2.DescribeIpamResourceDiscoveriesOutput, error)) *EC2_DescribeIpamResourceDiscoveries_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamResourceDiscoveryAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamResourceDiscoveryAssociations(ctx context.Context, params *ec2.DescribeIpamResourceDiscoveryAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamResourceDiscoveryAssociations")
	}

	var r0 *ec2.DescribeIpamResourceDiscoveryAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamResourceDiscoveryAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamResourceDiscoveryAssociationsInput, ...func(*ec2.Options)) *ec2.DescribeIpamResourceDiscoveryAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamResourceDiscoveryAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamResourceDiscoveryAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamResourceDiscoveryAssociations'
type EC2_DescribeIpamResourceDiscoveryAssociations_Call struct {
	*mock.Call
}

// DescribeIpamResourceDiscoveryAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamResourceDiscoveryAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamResourceDiscoveryAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamResourceDiscoveryAssociations_Call {
	return &EC2_DescribeIpamResourceDiscoveryAssociations_Call{Call: _e.mock.On("DescribeIpamResourceDiscoveryAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamResourceDiscoveryAssociations_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamResourceDiscoveryAssociationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamResourceDiscoveryAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamResourceDiscoveryAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamResourceDiscoveryAssociations_Call) Return(_a0 *ec2.DescribeIpamResourceDiscoveryAssociationsOutput, _a1 error) *EC2_DescribeIpamResourceDiscoveryAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamResourceDiscoveryAssociations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamResourceDiscoveryAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error)) *EC2_DescribeIpamResourceDiscoveryAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpamScopes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpamScopes(ctx context.Context, params *ec2.DescribeIpamScopesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamScopesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpamScopes")
	}

	var r0 *ec2.DescribeIpamScopesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamScopesInput, ...func(*ec2.Options)) (*ec2.DescribeIpamScopesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamScopesInput, ...func(*ec2.Options)) *ec2.DescribeIpamScopesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamScopesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamScopesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpamScopes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpamScopes'
type EC2_DescribeIpamScopes_Call struct {
	*mock.Call
}

// DescribeIpamScopes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamScopesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpamScopes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpamScopes_Call {
	return &EC2_DescribeIpamScopes_Call{Call: _e.mock.On("DescribeIpamScopes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpamScopes_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamScopesInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpamScopes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamScopesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpamScopes_Call) Return(_a0 *ec2.DescribeIpamScopesOutput, _a1 error) *EC2_DescribeIpamScopes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpamScopes_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamScopesInput, ...func(*ec2.Options)) (*ec2.DescribeIpamScopesOutput, error)) *EC2_DescribeIpamScopes_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpams provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpams(ctx context.Context, params *ec2.DescribeIpamsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpamsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpams")
	}

	var r0 *ec2.DescribeIpamsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamsInput, ...func(*ec2.Options)) (*ec2.DescribeIpamsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpamsInput, ...func(*ec2.Options)) *ec2.DescribeIpamsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpamsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpamsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpams'
type EC2_DescribeIpams_Call struct {
	*mock.Call
}

// DescribeIpams is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpamsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpams(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpams_Call {
	return &EC2_DescribeIpams_Call{Call: _e.mock.On("DescribeIpams",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpams_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpamsInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpamsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpams_Call) Return(_a0 *ec2.DescribeIpamsOutput, _a1 error) *EC2_DescribeIpams_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpams_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpamsInput, ...func(*ec2.Options)) (*ec2.DescribeIpamsOutput, error)) *EC2_DescribeIpams_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeIpv6Pools provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeIpv6Pools(ctx context.Context, params *ec2.DescribeIpv6PoolsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeIpv6PoolsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeIpv6Pools")
	}

	var r0 *ec2.DescribeIpv6PoolsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpv6PoolsInput, ...func(*ec2.Options)) (*ec2.DescribeIpv6PoolsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeIpv6PoolsInput, ...func(*ec2.Options)) *ec2.DescribeIpv6PoolsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeIpv6PoolsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeIpv6PoolsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeIpv6Pools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIpv6Pools'
type EC2_DescribeIpv6Pools_Call struct {
	*mock.Call
}

// DescribeIpv6Pools is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeIpv6PoolsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeIpv6Pools(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeIpv6Pools_Call {
	return &EC2_DescribeIpv6Pools_Call{Call: _e.mock.On("DescribeIpv6Pools",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeIpv6Pools_Call) Run(run func(ctx context.Context, params *ec2.DescribeIpv6PoolsInput, optFns ...func(*ec2.Options))) *EC2_DescribeIpv6Pools_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeIpv6PoolsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeIpv6Pools_Call) Return(_a0 *ec2.DescribeIpv6PoolsOutput, _a1 error) *EC2_DescribeIpv6Pools_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeIpv6Pools_Call) RunAndReturn(run func(context.Context, *ec2.DescribeIpv6PoolsInput, ...func(*ec2.Options)) (*ec2.DescribeIpv6PoolsOutput, error)) *EC2_DescribeIpv6Pools_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeKeyPairs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeKeyPairs(ctx context.Context, params *ec2.DescribeKeyPairsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeKeyPairsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeKeyPairs")
	}

	var r0 *ec2.DescribeKeyPairsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeKeyPairsInput, ...func(*ec2.Options)) (*ec2.DescribeKeyPairsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeKeyPairsInput, ...func(*ec2.Options)) *ec2.DescribeKeyPairsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeKeyPairsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeKeyPairsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeKeyPairs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeKeyPairs'
type EC2_DescribeKeyPairs_Call struct {
	*mock.Call
}

// DescribeKeyPairs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeKeyPairsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeKeyPairs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeKeyPairs_Call {
	return &EC2_DescribeKeyPairs_Call{Call: _e.mock.On("DescribeKeyPairs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeKeyPairs_Call) Run(run func(ctx context.Context, params *ec2.DescribeKeyPairsInput, optFns ...func(*ec2.Options))) *EC2_DescribeKeyPairs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeKeyPairsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeKeyPairs_Call) Return(_a0 *ec2.DescribeKeyPairsOutput, _a1 error) *EC2_DescribeKeyPairs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeKeyPairs_Call) RunAndReturn(run func(context.Context, *ec2.DescribeKeyPairsInput, ...func(*ec2.Options)) (*ec2.DescribeKeyPairsOutput, error)) *EC2_DescribeKeyPairs_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLaunchTemplateVersions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLaunchTemplateVersions(ctx context.Context, params *ec2.DescribeLaunchTemplateVersionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLaunchTemplateVersionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLaunchTemplateVersions")
	}

	var r0 *ec2.DescribeLaunchTemplateVersionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLaunchTemplateVersionsInput, ...func(*ec2.Options)) (*ec2.DescribeLaunchTemplateVersionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLaunchTemplateVersionsInput, ...func(*ec2.Options)) *ec2.DescribeLaunchTemplateVersionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLaunchTemplateVersionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLaunchTemplateVersionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLaunchTemplateVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLaunchTemplateVersions'
type EC2_DescribeLaunchTemplateVersions_Call struct {
	*mock.Call
}

// DescribeLaunchTemplateVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLaunchTemplateVersionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLaunchTemplateVersions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLaunchTemplateVersions_Call {
	return &EC2_DescribeLaunchTemplateVersions_Call{Call: _e.mock.On("DescribeLaunchTemplateVersions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLaunchTemplateVersions_Call) Run(run func(ctx context.Context, params *ec2.DescribeLaunchTemplateVersionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeLaunchTemplateVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLaunchTemplateVersionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLaunchTemplateVersions_Call) Return(_a0 *ec2.DescribeLaunchTemplateVersionsOutput, _a1 error) *EC2_DescribeLaunchTemplateVersions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLaunchTemplateVersions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLaunchTemplateVersionsInput, ...func(*ec2.Options)) (*ec2.DescribeLaunchTemplateVersionsOutput, error)) *EC2_DescribeLaunchTemplateVersions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLaunchTemplates provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLaunchTemplates(ctx context.Context, params *ec2.DescribeLaunchTemplatesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLaunchTemplatesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLaunchTemplates")
	}

	var r0 *ec2.DescribeLaunchTemplatesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLaunchTemplatesInput, ...func(*ec2.Options)) (*ec2.DescribeLaunchTemplatesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLaunchTemplatesInput, ...func(*ec2.Options)) *ec2.DescribeLaunchTemplatesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLaunchTemplatesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLaunchTemplatesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLaunchTemplates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLaunchTemplates'
type EC2_DescribeLaunchTemplates_Call struct {
	*mock.Call
}

// DescribeLaunchTemplates is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLaunchTemplatesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLaunchTemplates(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLaunchTemplates_Call {
	return &EC2_DescribeLaunchTemplates_Call{Call: _e.mock.On("DescribeLaunchTemplates",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLaunchTemplates_Call) Run(run func(ctx context.Context, params *ec2.DescribeLaunchTemplatesInput, optFns ...func(*ec2.Options))) *EC2_DescribeLaunchTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLaunchTemplatesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLaunchTemplates_Call) Return(_a0 *ec2.DescribeLaunchTemplatesOutput, _a1 error) *EC2_DescribeLaunchTemplates_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLaunchTemplates_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLaunchTemplatesInput, ...func(*ec2.Options)) (*ec2.DescribeLaunchTemplatesOutput, error)) *EC2_DescribeLaunchTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(ctx context.Context, params *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations")
	}

	var r0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, ...func(*ec2.Options)) *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations'
type EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call struct {
	*mock.Call
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call {
	return &EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call{Call: _e.mock.On("DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call) Run(run func(ctx context.Context, params *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call) Return(_a0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, _a1 error) *EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error)) *EC2_DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLocalGatewayRouteTableVpcAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLocalGatewayRouteTableVpcAssociations(ctx context.Context, params *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLocalGatewayRouteTableVpcAssociations")
	}

	var r0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, ...func(*ec2.Options)) *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLocalGatewayRouteTableVpcAssociations'
type EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call struct {
	*mock.Call
}

// DescribeLocalGatewayRouteTableVpcAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLocalGatewayRouteTableVpcAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call {
	return &EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call{Call: _e.mock.On("DescribeLocalGatewayRouteTableVpcAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call) Run(run func(ctx context.Context, params *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call) Return(_a0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, _a1 error) *EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error)) *EC2_DescribeLocalGatewayRouteTableVpcAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLocalGatewayRouteTables provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLocalGatewayRouteTables(ctx context.Context, params *ec2.DescribeLocalGatewayRouteTablesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLocalGatewayRouteTables")
	}

	var r0 *ec2.DescribeLocalGatewayRouteTablesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTablesInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTablesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayRouteTablesInput, ...func(*ec2.Options)) *ec2.DescribeLocalGatewayRouteTablesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayRouteTablesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLocalGatewayRouteTablesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLocalGatewayRouteTables_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLocalGatewayRouteTables'
type EC2_DescribeLocalGatewayRouteTables_Call struct {
	*mock.Call
}

// DescribeLocalGatewayRouteTables is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLocalGatewayRouteTablesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLocalGatewayRouteTables(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLocalGatewayRouteTables_Call {
	return &EC2_DescribeLocalGatewayRouteTables_Call{Call: _e.mock.On("DescribeLocalGatewayRouteTables",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLocalGatewayRouteTables_Call) Run(run func(ctx context.Context, params *ec2.DescribeLocalGatewayRouteTablesInput, optFns ...func(*ec2.Options))) *EC2_DescribeLocalGatewayRouteTables_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLocalGatewayRouteTablesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLocalGatewayRouteTables_Call) Return(_a0 *ec2.DescribeLocalGatewayRouteTablesOutput, _a1 error) *EC2_DescribeLocalGatewayRouteTables_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLocalGatewayRouteTables_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLocalGatewayRouteTablesInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayRouteTablesOutput, error)) *EC2_DescribeLocalGatewayRouteTables_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLocalGatewayVirtualInterfaceGroups provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLocalGatewayVirtualInterfaceGroups(ctx context.Context, params *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLocalGatewayVirtualInterfaceGroups")
	}

	var r0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, ...func(*ec2.Options)) *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLocalGatewayVirtualInterfaceGroups'
type EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call struct {
	*mock.Call
}

// DescribeLocalGatewayVirtualInterfaceGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLocalGatewayVirtualInterfaceGroups(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call {
	return &EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call{Call: _e.mock.On("DescribeLocalGatewayVirtualInterfaceGroups",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call) Run(run func(ctx context.Context, params *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, optFns ...func(*ec2.Options))) *EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call) Return(_a0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, _a1 error) *EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error)) *EC2_DescribeLocalGatewayVirtualInterfaceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLocalGatewayVirtualInterfaces provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLocalGatewayVirtualInterfaces(ctx context.Context, params *ec2.DescribeLocalGatewayVirtualInterfacesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLocalGatewayVirtualInterfaces")
	}

	var r0 *ec2.DescribeLocalGatewayVirtualInterfacesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfacesInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfacesInput, ...func(*ec2.Options)) *ec2.DescribeLocalGatewayVirtualInterfacesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfacesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLocalGatewayVirtualInterfaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLocalGatewayVirtualInterfaces'
type EC2_DescribeLocalGatewayVirtualInterfaces_Call struct {
	*mock.Call
}

// DescribeLocalGatewayVirtualInterfaces is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLocalGatewayVirtualInterfacesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLocalGatewayVirtualInterfaces(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLocalGatewayVirtualInterfaces_Call {
	return &EC2_DescribeLocalGatewayVirtualInterfaces_Call{Call: _e.mock.On("DescribeLocalGatewayVirtualInterfaces",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLocalGatewayVirtualInterfaces_Call) Run(run func(ctx context.Context, params *ec2.DescribeLocalGatewayVirtualInterfacesInput, optFns ...func(*ec2.Options))) *EC2_DescribeLocalGatewayVirtualInterfaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLocalGatewayVirtualInterfacesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLocalGatewayVirtualInterfaces_Call) Return(_a0 *ec2.DescribeLocalGatewayVirtualInterfacesOutput, _a1 error) *EC2_DescribeLocalGatewayVirtualInterfaces_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLocalGatewayVirtualInterfaces_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLocalGatewayVirtualInterfacesInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error)) *EC2_DescribeLocalGatewayVirtualInterfaces_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLocalGateways provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLocalGateways(ctx context.Context, params *ec2.DescribeLocalGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLocalGatewaysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLocalGateways")
	}

	var r0 *ec2.DescribeLocalGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewaysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLocalGatewaysInput, ...func(*ec2.Options)) *ec2.DescribeLocalGatewaysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLocalGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLocalGatewaysInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLocalGateways_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLocalGateways'
type EC2_DescribeLocalGateways_Call struct {
	*mock.Call
}

// DescribeLocalGateways is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLocalGatewaysInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLocalGateways(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLocalGateways_Call {
	return &EC2_DescribeLocalGateways_Call{Call: _e.mock.On("DescribeLocalGateways",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLocalGateways_Call) Run(run func(ctx context.Context, params *ec2.DescribeLocalGatewaysInput, optFns ...func(*ec2.Options))) *EC2_DescribeLocalGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLocalGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLocalGateways_Call) Return(_a0 *ec2.DescribeLocalGatewaysOutput, _a1 error) *EC2_DescribeLocalGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLocalGateways_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLocalGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeLocalGatewaysOutput, error)) *EC2_DescribeLocalGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeLockedSnapshots provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeLockedSnapshots(ctx context.Context, params *ec2.DescribeLockedSnapshotsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeLockedSnapshotsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeLockedSnapshots")
	}

	var r0 *ec2.DescribeLockedSnapshotsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLockedSnapshotsInput, ...func(*ec2.Options)) (*ec2.DescribeLockedSnapshotsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeLockedSnapshotsInput, ...func(*ec2.Options)) *ec2.DescribeLockedSnapshotsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeLockedSnapshotsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeLockedSnapshotsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeLockedSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeLockedSnapshots'
type EC2_DescribeLockedSnapshots_Call struct {
	*mock.Call
}

// DescribeLockedSnapshots is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeLockedSnapshotsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeLockedSnapshots(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeLockedSnapshots_Call {
	return &EC2_DescribeLockedSnapshots_Call{Call: _e.mock.On("DescribeLockedSnapshots",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeLockedSnapshots_Call) Run(run func(ctx context.Context, params *ec2.DescribeLockedSnapshotsInput, optFns ...func(*ec2.Options))) *EC2_DescribeLockedSnapshots_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeLockedSnapshotsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeLockedSnapshots_Call) Return(_a0 *ec2.DescribeLockedSnapshotsOutput, _a1 error) *EC2_DescribeLockedSnapshots_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeLockedSnapshots_Call) RunAndReturn(run func(context.Context, *ec2.DescribeLockedSnapshotsInput, ...func(*ec2.Options)) (*ec2.DescribeLockedSnapshotsOutput, error)) *EC2_DescribeLockedSnapshots_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeMacHosts provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeMacHosts(ctx context.Context, params *ec2.DescribeMacHostsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeMacHostsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeMacHosts")
	}

	var r0 *ec2.DescribeMacHostsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeMacHostsInput, ...func(*ec2.Options)) (*ec2.DescribeMacHostsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeMacHostsInput, ...func(*ec2.Options)) *ec2.DescribeMacHostsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeMacHostsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeMacHostsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeMacHosts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeMacHosts'
type EC2_DescribeMacHosts_Call struct {
	*mock.Call
}

// DescribeMacHosts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeMacHostsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeMacHosts(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeMacHosts_Call {
	return &EC2_DescribeMacHosts_Call{Call: _e.mock.On("DescribeMacHosts",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeMacHosts_Call) Run(run func(ctx context.Context, params *ec2.DescribeMacHostsInput, optFns ...func(*ec2.Options))) *EC2_DescribeMacHosts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeMacHostsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeMacHosts_Call) Return(_a0 *ec2.DescribeMacHostsOutput, _a1 error) *EC2_DescribeMacHosts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeMacHosts_Call) RunAndReturn(run func(context.Context, *ec2.DescribeMacHostsInput, ...func(*ec2.Options)) (*ec2.DescribeMacHostsOutput, error)) *EC2_DescribeMacHosts_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeMacModificationTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeMacModificationTasks(ctx context.Context, params *ec2.DescribeMacModificationTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeMacModificationTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeMacModificationTasks")
	}

	var r0 *ec2.DescribeMacModificationTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeMacModificationTasksInput, ...func(*ec2.Options)) (*ec2.DescribeMacModificationTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeMacModificationTasksInput, ...func(*ec2.Options)) *ec2.DescribeMacModificationTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeMacModificationTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeMacModificationTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeMacModificationTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeMacModificationTasks'
type EC2_DescribeMacModificationTasks_Call struct {
	*mock.Call
}

// DescribeMacModificationTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeMacModificationTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeMacModificationTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeMacModificationTasks_Call {
	return &EC2_DescribeMacModificationTasks_Call{Call: _e.mock.On("DescribeMacModificationTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeMacModificationTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeMacModificationTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeMacModificationTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeMacModificationTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeMacModificationTasks_Call) Return(_a0 *ec2.DescribeMacModificationTasksOutput, _a1 error) *EC2_DescribeMacModificationTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeMacModificationTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeMacModificationTasksInput, ...func(*ec2.Options)) (*ec2.DescribeMacModificationTasksOutput, error)) *EC2_DescribeMacModificationTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeManagedPrefixLists provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeManagedPrefixLists(ctx context.Context, params *ec2.DescribeManagedPrefixListsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeManagedPrefixListsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeManagedPrefixLists")
	}

	var r0 *ec2.DescribeManagedPrefixListsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeManagedPrefixListsInput, ...func(*ec2.Options)) (*ec2.DescribeManagedPrefixListsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeManagedPrefixListsInput, ...func(*ec2.Options)) *ec2.DescribeManagedPrefixListsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeManagedPrefixListsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeManagedPrefixListsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeManagedPrefixLists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeManagedPrefixLists'
type EC2_DescribeManagedPrefixLists_Call struct {
	*mock.Call
}

// DescribeManagedPrefixLists is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeManagedPrefixListsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeManagedPrefixLists(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeManagedPrefixLists_Call {
	return &EC2_DescribeManagedPrefixLists_Call{Call: _e.mock.On("DescribeManagedPrefixLists",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeManagedPrefixLists_Call) Run(run func(ctx context.Context, params *ec2.DescribeManagedPrefixListsInput, optFns ...func(*ec2.Options))) *EC2_DescribeManagedPrefixLists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeManagedPrefixListsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeManagedPrefixLists_Call) Return(_a0 *ec2.DescribeManagedPrefixListsOutput, _a1 error) *EC2_DescribeManagedPrefixLists_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeManagedPrefixLists_Call) RunAndReturn(run func(context.Context, *ec2.DescribeManagedPrefixListsInput, ...func(*ec2.Options)) (*ec2.DescribeManagedPrefixListsOutput, error)) *EC2_DescribeManagedPrefixLists_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeMovingAddresses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeMovingAddresses(ctx context.Context, params *ec2.DescribeMovingAddressesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeMovingAddressesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeMovingAddresses")
	}

	var r0 *ec2.DescribeMovingAddressesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeMovingAddressesInput, ...func(*ec2.Options)) (*ec2.DescribeMovingAddressesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeMovingAddressesInput, ...func(*ec2.Options)) *ec2.DescribeMovingAddressesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeMovingAddressesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeMovingAddressesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeMovingAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeMovingAddresses'
type EC2_DescribeMovingAddresses_Call struct {
	*mock.Call
}

// DescribeMovingAddresses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeMovingAddressesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeMovingAddresses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeMovingAddresses_Call {
	return &EC2_DescribeMovingAddresses_Call{Call: _e.mock.On("DescribeMovingAddresses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeMovingAddresses_Call) Run(run func(ctx context.Context, params *ec2.DescribeMovingAddressesInput, optFns ...func(*ec2.Options))) *EC2_DescribeMovingAddresses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeMovingAddressesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeMovingAddresses_Call) Return(_a0 *ec2.DescribeMovingAddressesOutput, _a1 error) *EC2_DescribeMovingAddresses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeMovingAddresses_Call) RunAndReturn(run func(context.Context, *ec2.DescribeMovingAddressesInput, ...func(*ec2.Options)) (*ec2.DescribeMovingAddressesOutput, error)) *EC2_DescribeMovingAddresses_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNatGateways provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNatGateways(ctx context.Context, params *ec2.DescribeNatGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNatGatewaysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNatGateways")
	}

	var r0 *ec2.DescribeNatGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNatGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeNatGatewaysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNatGatewaysInput, ...func(*ec2.Options)) *ec2.DescribeNatGatewaysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNatGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNatGatewaysInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNatGateways_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNatGateways'
type EC2_DescribeNatGateways_Call struct {
	*mock.Call
}

// DescribeNatGateways is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNatGatewaysInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNatGateways(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNatGateways_Call {
	return &EC2_DescribeNatGateways_Call{Call: _e.mock.On("DescribeNatGateways",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNatGateways_Call) Run(run func(ctx context.Context, params *ec2.DescribeNatGatewaysInput, optFns ...func(*ec2.Options))) *EC2_DescribeNatGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNatGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNatGateways_Call) Return(_a0 *ec2.DescribeNatGatewaysOutput, _a1 error) *EC2_DescribeNatGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNatGateways_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNatGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeNatGatewaysOutput, error)) *EC2_DescribeNatGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkAcls provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNetworkAcls(ctx context.Context, params *ec2.DescribeNetworkAclsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkAclsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNetworkAcls")
	}

	var r0 *ec2.DescribeNetworkAclsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkAclsInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkAclsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkAclsInput, ...func(*ec2.Options)) *ec2.DescribeNetworkAclsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkAclsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNetworkAclsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNetworkAcls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNetworkAcls'
type EC2_DescribeNetworkAcls_Call struct {
	*mock.Call
}

// DescribeNetworkAcls is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNetworkAclsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNetworkAcls(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNetworkAcls_Call {
	return &EC2_DescribeNetworkAcls_Call{Call: _e.mock.On("DescribeNetworkAcls",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNetworkAcls_Call) Run(run func(ctx context.Context, params *ec2.DescribeNetworkAclsInput, optFns ...func(*ec2.Options))) *EC2_DescribeNetworkAcls_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNetworkAclsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNetworkAcls_Call) Return(_a0 *ec2.DescribeNetworkAclsOutput, _a1 error) *EC2_DescribeNetworkAcls_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNetworkAcls_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNetworkAclsInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkAclsOutput, error)) *EC2_DescribeNetworkAcls_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkInsightsAccessScopeAnalyses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNetworkInsightsAccessScopeAnalyses(ctx context.Context, params *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNetworkInsightsAccessScopeAnalyses")
	}

	var r0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, ...func(*ec2.Options)) *ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNetworkInsightsAccessScopeAnalyses'
type EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call struct {
	*mock.Call
}

// DescribeNetworkInsightsAccessScopeAnalyses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNetworkInsightsAccessScopeAnalyses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call {
	return &EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call{Call: _e.mock.On("DescribeNetworkInsightsAccessScopeAnalyses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call) Run(run func(ctx context.Context, params *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, optFns ...func(*ec2.Options))) *EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call) Return(_a0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, _a1 error) *EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error)) *EC2_DescribeNetworkInsightsAccessScopeAnalyses_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkInsightsAccessScopes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNetworkInsightsAccessScopes(ctx context.Context, params *ec2.DescribeNetworkInsightsAccessScopesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNetworkInsightsAccessScopes")
	}

	var r0 *ec2.DescribeNetworkInsightsAccessScopesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsAccessScopesInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsAccessScopesInput, ...func(*ec2.Options)) *ec2.DescribeNetworkInsightsAccessScopesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInsightsAccessScopesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNetworkInsightsAccessScopesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNetworkInsightsAccessScopes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNetworkInsightsAccessScopes'
type EC2_DescribeNetworkInsightsAccessScopes_Call struct {
	*mock.Call
}

// DescribeNetworkInsightsAccessScopes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNetworkInsightsAccessScopesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNetworkInsightsAccessScopes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNetworkInsightsAccessScopes_Call {
	return &EC2_DescribeNetworkInsightsAccessScopes_Call{Call: _e.mock.On("DescribeNetworkInsightsAccessScopes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNetworkInsightsAccessScopes_Call) Run(run func(ctx context.Context, params *ec2.DescribeNetworkInsightsAccessScopesInput, optFns ...func(*ec2.Options))) *EC2_DescribeNetworkInsightsAccessScopes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNetworkInsightsAccessScopesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNetworkInsightsAccessScopes_Call) Return(_a0 *ec2.DescribeNetworkInsightsAccessScopesOutput, _a1 error) *EC2_DescribeNetworkInsightsAccessScopes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNetworkInsightsAccessScopes_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNetworkInsightsAccessScopesInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error)) *EC2_DescribeNetworkInsightsAccessScopes_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkInsightsAnalyses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNetworkInsightsAnalyses(ctx context.Context, params *ec2.DescribeNetworkInsightsAnalysesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAnalysesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNetworkInsightsAnalyses")
	}

	var r0 *ec2.DescribeNetworkInsightsAnalysesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsAnalysesInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAnalysesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsAnalysesInput, ...func(*ec2.Options)) *ec2.DescribeNetworkInsightsAnalysesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInsightsAnalysesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNetworkInsightsAnalysesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNetworkInsightsAnalyses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNetworkInsightsAnalyses'
type EC2_DescribeNetworkInsightsAnalyses_Call struct {
	*mock.Call
}

// DescribeNetworkInsightsAnalyses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNetworkInsightsAnalysesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNetworkInsightsAnalyses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNetworkInsightsAnalyses_Call {
	return &EC2_DescribeNetworkInsightsAnalyses_Call{Call: _e.mock.On("DescribeNetworkInsightsAnalyses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNetworkInsightsAnalyses_Call) Run(run func(ctx context.Context, params *ec2.DescribeNetworkInsightsAnalysesInput, optFns ...func(*ec2.Options))) *EC2_DescribeNetworkInsightsAnalyses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNetworkInsightsAnalysesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNetworkInsightsAnalyses_Call) Return(_a0 *ec2.DescribeNetworkInsightsAnalysesOutput, _a1 error) *EC2_DescribeNetworkInsightsAnalyses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNetworkInsightsAnalyses_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNetworkInsightsAnalysesInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsAnalysesOutput, error)) *EC2_DescribeNetworkInsightsAnalyses_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkInsightsPaths provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNetworkInsightsPaths(ctx context.Context, params *ec2.DescribeNetworkInsightsPathsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsPathsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNetworkInsightsPaths")
	}

	var r0 *ec2.DescribeNetworkInsightsPathsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsPathsInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsPathsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInsightsPathsInput, ...func(*ec2.Options)) *ec2.DescribeNetworkInsightsPathsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInsightsPathsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNetworkInsightsPathsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNetworkInsightsPaths_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNetworkInsightsPaths'
type EC2_DescribeNetworkInsightsPaths_Call struct {
	*mock.Call
}

// DescribeNetworkInsightsPaths is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNetworkInsightsPathsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNetworkInsightsPaths(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNetworkInsightsPaths_Call {
	return &EC2_DescribeNetworkInsightsPaths_Call{Call: _e.mock.On("DescribeNetworkInsightsPaths",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNetworkInsightsPaths_Call) Run(run func(ctx context.Context, params *ec2.DescribeNetworkInsightsPathsInput, optFns ...func(*ec2.Options))) *EC2_DescribeNetworkInsightsPaths_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNetworkInsightsPathsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNetworkInsightsPaths_Call) Return(_a0 *ec2.DescribeNetworkInsightsPathsOutput, _a1 error) *EC2_DescribeNetworkInsightsPaths_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNetworkInsightsPaths_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNetworkInsightsPathsInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInsightsPathsOutput, error)) *EC2_DescribeNetworkInsightsPaths_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkInterfaceAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNetworkInterfaceAttribute(ctx context.Context, params *ec2.DescribeNetworkInterfaceAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNetworkInterfaceAttribute")
	}

	var r0 *ec2.DescribeNetworkInterfaceAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfaceAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfaceAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfaceAttributeInput, ...func(*ec2.Options)) *ec2.DescribeNetworkInterfaceAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfaceAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNetworkInterfaceAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNetworkInterfaceAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNetworkInterfaceAttribute'
type EC2_DescribeNetworkInterfaceAttribute_Call struct {
	*mock.Call
}

// DescribeNetworkInterfaceAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNetworkInterfaceAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNetworkInterfaceAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNetworkInterfaceAttribute_Call {
	return &EC2_DescribeNetworkInterfaceAttribute_Call{Call: _e.mock.On("DescribeNetworkInterfaceAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNetworkInterfaceAttribute_Call) Run(run func(ctx context.Context, params *ec2.DescribeNetworkInterfaceAttributeInput, optFns ...func(*ec2.Options))) *EC2_DescribeNetworkInterfaceAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNetworkInterfaceAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNetworkInterfaceAttribute_Call) Return(_a0 *ec2.DescribeNetworkInterfaceAttributeOutput, _a1 error) *EC2_DescribeNetworkInterfaceAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNetworkInterfaceAttribute_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNetworkInterfaceAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfaceAttributeOutput, error)) *EC2_DescribeNetworkInterfaceAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkInterfacePermissions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNetworkInterfacePermissions(ctx context.Context, params *ec2.DescribeNetworkInterfacePermissionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNetworkInterfacePermissions")
	}

	var r0 *ec2.DescribeNetworkInterfacePermissionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfacePermissionsInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfacePermissionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfacePermissionsInput, ...func(*ec2.Options)) *ec2.DescribeNetworkInterfacePermissionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfacePermissionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNetworkInterfacePermissionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNetworkInterfacePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNetworkInterfacePermissions'
type EC2_DescribeNetworkInterfacePermissions_Call struct {
	*mock.Call
}

// DescribeNetworkInterfacePermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNetworkInterfacePermissionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNetworkInterfacePermissions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNetworkInterfacePermissions_Call {
	return &EC2_DescribeNetworkInterfacePermissions_Call{Call: _e.mock.On("DescribeNetworkInterfacePermissions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNetworkInterfacePermissions_Call) Run(run func(ctx context.Context, params *ec2.DescribeNetworkInterfacePermissionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeNetworkInterfacePermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNetworkInterfacePermissionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNetworkInterfacePermissions_Call) Return(_a0 *ec2.DescribeNetworkInterfacePermissionsOutput, _a1 error) *EC2_DescribeNetworkInterfacePermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNetworkInterfacePermissions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNetworkInterfacePermissionsInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfacePermissionsOutput, error)) *EC2_DescribeNetworkInterfacePermissions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkInterfaces provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeNetworkInterfaces(ctx context.Context, params *ec2.DescribeNetworkInterfacesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfacesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeNetworkInterfaces")
	}

	var r0 *ec2.DescribeNetworkInterfacesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfacesInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfacesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeNetworkInterfacesInput, ...func(*ec2.Options)) *ec2.DescribeNetworkInterfacesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeNetworkInterfacesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeNetworkInterfacesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeNetworkInterfaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeNetworkInterfaces'
type EC2_DescribeNetworkInterfaces_Call struct {
	*mock.Call
}

// DescribeNetworkInterfaces is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeNetworkInterfacesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeNetworkInterfaces(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeNetworkInterfaces_Call {
	return &EC2_DescribeNetworkInterfaces_Call{Call: _e.mock.On("DescribeNetworkInterfaces",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeNetworkInterfaces_Call) Run(run func(ctx context.Context, params *ec2.DescribeNetworkInterfacesInput, optFns ...func(*ec2.Options))) *EC2_DescribeNetworkInterfaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeNetworkInterfacesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeNetworkInterfaces_Call) Return(_a0 *ec2.DescribeNetworkInterfacesOutput, _a1 error) *EC2_DescribeNetworkInterfaces_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeNetworkInterfaces_Call) RunAndReturn(run func(context.Context, *ec2.DescribeNetworkInterfacesInput, ...func(*ec2.Options)) (*ec2.DescribeNetworkInterfacesOutput, error)) *EC2_DescribeNetworkInterfaces_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeOutpostLags provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeOutpostLags(ctx context.Context, params *ec2.DescribeOutpostLagsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeOutpostLagsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeOutpostLags")
	}

	var r0 *ec2.DescribeOutpostLagsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeOutpostLagsInput, ...func(*ec2.Options)) (*ec2.DescribeOutpostLagsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeOutpostLagsInput, ...func(*ec2.Options)) *ec2.DescribeOutpostLagsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeOutpostLagsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeOutpostLagsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeOutpostLags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeOutpostLags'
type EC2_DescribeOutpostLags_Call struct {
	*mock.Call
}

// DescribeOutpostLags is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeOutpostLagsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeOutpostLags(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeOutpostLags_Call {
	return &EC2_DescribeOutpostLags_Call{Call: _e.mock.On("DescribeOutpostLags",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeOutpostLags_Call) Run(run func(ctx context.Context, params *ec2.DescribeOutpostLagsInput, optFns ...func(*ec2.Options))) *EC2_DescribeOutpostLags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeOutpostLagsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeOutpostLags_Call) Return(_a0 *ec2.DescribeOutpostLagsOutput, _a1 error) *EC2_DescribeOutpostLags_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeOutpostLags_Call) RunAndReturn(run func(context.Context, *ec2.DescribeOutpostLagsInput, ...func(*ec2.Options)) (*ec2.DescribeOutpostLagsOutput, error)) *EC2_DescribeOutpostLags_Call {
	_c.Call.Return(run)
	return _c
}

// DescribePlacementGroups provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribePlacementGroups(ctx context.Context, params *ec2.DescribePlacementGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribePlacementGroupsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribePlacementGroups")
	}

	var r0 *ec2.DescribePlacementGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePlacementGroupsInput, ...func(*ec2.Options)) (*ec2.DescribePlacementGroupsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePlacementGroupsInput, ...func(*ec2.Options)) *ec2.DescribePlacementGroupsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePlacementGroupsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribePlacementGroupsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribePlacementGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribePlacementGroups'
type EC2_DescribePlacementGroups_Call struct {
	*mock.Call
}

// DescribePlacementGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribePlacementGroupsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribePlacementGroups(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribePlacementGroups_Call {
	return &EC2_DescribePlacementGroups_Call{Call: _e.mock.On("DescribePlacementGroups",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribePlacementGroups_Call) Run(run func(ctx context.Context, params *ec2.DescribePlacementGroupsInput, optFns ...func(*ec2.Options))) *EC2_DescribePlacementGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribePlacementGroupsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribePlacementGroups_Call) Return(_a0 *ec2.DescribePlacementGroupsOutput, _a1 error) *EC2_DescribePlacementGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribePlacementGroups_Call) RunAndReturn(run func(context.Context, *ec2.DescribePlacementGroupsInput, ...func(*ec2.Options)) (*ec2.DescribePlacementGroupsOutput, error)) *EC2_DescribePlacementGroups_Call {
	_c.Call.Return(run)
	return _c
}

// DescribePrefixLists provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribePrefixLists(ctx context.Context, params *ec2.DescribePrefixListsInput, optFns ...func(*ec2.Options)) (*ec2.DescribePrefixListsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribePrefixLists")
	}

	var r0 *ec2.DescribePrefixListsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePrefixListsInput, ...func(*ec2.Options)) (*ec2.DescribePrefixListsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePrefixListsInput, ...func(*ec2.Options)) *ec2.DescribePrefixListsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePrefixListsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribePrefixListsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribePrefixLists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribePrefixLists'
type EC2_DescribePrefixLists_Call struct {
	*mock.Call
}

// DescribePrefixLists is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribePrefixListsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribePrefixLists(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribePrefixLists_Call {
	return &EC2_DescribePrefixLists_Call{Call: _e.mock.On("DescribePrefixLists",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribePrefixLists_Call) Run(run func(ctx context.Context, params *ec2.DescribePrefixListsInput, optFns ...func(*ec2.Options))) *EC2_DescribePrefixLists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribePrefixListsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribePrefixLists_Call) Return(_a0 *ec2.DescribePrefixListsOutput, _a1 error) *EC2_DescribePrefixLists_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribePrefixLists_Call) RunAndReturn(run func(context.Context, *ec2.DescribePrefixListsInput, ...func(*ec2.Options)) (*ec2.DescribePrefixListsOutput, error)) *EC2_DescribePrefixLists_Call {
	_c.Call.Return(run)
	return _c
}

// DescribePrincipalIdFormat provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribePrincipalIdFormat(ctx context.Context, params *ec2.DescribePrincipalIdFormatInput, optFns ...func(*ec2.Options)) (*ec2.DescribePrincipalIdFormatOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribePrincipalIdFormat")
	}

	var r0 *ec2.DescribePrincipalIdFormatOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePrincipalIdFormatInput, ...func(*ec2.Options)) (*ec2.DescribePrincipalIdFormatOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePrincipalIdFormatInput, ...func(*ec2.Options)) *ec2.DescribePrincipalIdFormatOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePrincipalIdFormatOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribePrincipalIdFormatInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribePrincipalIdFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribePrincipalIdFormat'
type EC2_DescribePrincipalIdFormat_Call struct {
	*mock.Call
}

// DescribePrincipalIdFormat is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribePrincipalIdFormatInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribePrincipalIdFormat(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribePrincipalIdFormat_Call {
	return &EC2_DescribePrincipalIdFormat_Call{Call: _e.mock.On("DescribePrincipalIdFormat",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribePrincipalIdFormat_Call) Run(run func(ctx context.Context, params *ec2.DescribePrincipalIdFormatInput, optFns ...func(*ec2.Options))) *EC2_DescribePrincipalIdFormat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribePrincipalIdFormatInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribePrincipalIdFormat_Call) Return(_a0 *ec2.DescribePrincipalIdFormatOutput, _a1 error) *EC2_DescribePrincipalIdFormat_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribePrincipalIdFormat_Call) RunAndReturn(run func(context.Context, *ec2.DescribePrincipalIdFormatInput, ...func(*ec2.Options)) (*ec2.DescribePrincipalIdFormatOutput, error)) *EC2_DescribePrincipalIdFormat_Call {
	_c.Call.Return(run)
	return _c
}

// DescribePublicIpv4Pools provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribePublicIpv4Pools(ctx context.Context, params *ec2.DescribePublicIpv4PoolsInput, optFns ...func(*ec2.Options)) (*ec2.DescribePublicIpv4PoolsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribePublicIpv4Pools")
	}

	var r0 *ec2.DescribePublicIpv4PoolsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePublicIpv4PoolsInput, ...func(*ec2.Options)) (*ec2.DescribePublicIpv4PoolsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribePublicIpv4PoolsInput, ...func(*ec2.Options)) *ec2.DescribePublicIpv4PoolsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribePublicIpv4PoolsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribePublicIpv4PoolsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribePublicIpv4Pools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribePublicIpv4Pools'
type EC2_DescribePublicIpv4Pools_Call struct {
	*mock.Call
}

// DescribePublicIpv4Pools is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribePublicIpv4PoolsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribePublicIpv4Pools(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribePublicIpv4Pools_Call {
	return &EC2_DescribePublicIpv4Pools_Call{Call: _e.mock.On("DescribePublicIpv4Pools",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribePublicIpv4Pools_Call) Run(run func(ctx context.Context, params *ec2.DescribePublicIpv4PoolsInput, optFns ...func(*ec2.Options))) *EC2_DescribePublicIpv4Pools_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribePublicIpv4PoolsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribePublicIpv4Pools_Call) Return(_a0 *ec2.DescribePublicIpv4PoolsOutput, _a1 error) *EC2_DescribePublicIpv4Pools_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribePublicIpv4Pools_Call) RunAndReturn(run func(context.Context, *ec2.DescribePublicIpv4PoolsInput, ...func(*ec2.Options)) (*ec2.DescribePublicIpv4PoolsOutput, error)) *EC2_DescribePublicIpv4Pools_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeRegions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeRegions(ctx context.Context, params *ec2.DescribeRegionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeRegionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeRegions")
	}

	var r0 *ec2.DescribeRegionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRegionsInput, ...func(*ec2.Options)) (*ec2.DescribeRegionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRegionsInput, ...func(*ec2.Options)) *ec2.DescribeRegionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRegionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeRegionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeRegions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeRegions'
type EC2_DescribeRegions_Call struct {
	*mock.Call
}

// DescribeRegions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeRegionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeRegions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeRegions_Call {
	return &EC2_DescribeRegions_Call{Call: _e.mock.On("DescribeRegions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeRegions_Call) Run(run func(ctx context.Context, params *ec2.DescribeRegionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeRegions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeRegionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeRegions_Call) Return(_a0 *ec2.DescribeRegionsOutput, _a1 error) *EC2_DescribeRegions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeRegions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeRegionsInput, ...func(*ec2.Options)) (*ec2.DescribeRegionsOutput, error)) *EC2_DescribeRegions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeReplaceRootVolumeTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeReplaceRootVolumeTasks(ctx context.Context, params *ec2.DescribeReplaceRootVolumeTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeReplaceRootVolumeTasks")
	}

	var r0 *ec2.DescribeReplaceRootVolumeTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReplaceRootVolumeTasksInput, ...func(*ec2.Options)) (*ec2.DescribeReplaceRootVolumeTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReplaceRootVolumeTasksInput, ...func(*ec2.Options)) *ec2.DescribeReplaceRootVolumeTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReplaceRootVolumeTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeReplaceRootVolumeTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeReplaceRootVolumeTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeReplaceRootVolumeTasks'
type EC2_DescribeReplaceRootVolumeTasks_Call struct {
	*mock.Call
}

// DescribeReplaceRootVolumeTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeReplaceRootVolumeTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeReplaceRootVolumeTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeReplaceRootVolumeTasks_Call {
	return &EC2_DescribeReplaceRootVolumeTasks_Call{Call: _e.mock.On("DescribeReplaceRootVolumeTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeReplaceRootVolumeTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeReplaceRootVolumeTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeReplaceRootVolumeTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeReplaceRootVolumeTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeReplaceRootVolumeTasks_Call) Return(_a0 *ec2.DescribeReplaceRootVolumeTasksOutput, _a1 error) *EC2_DescribeReplaceRootVolumeTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeReplaceRootVolumeTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeReplaceRootVolumeTasksInput, ...func(*ec2.Options)) (*ec2.DescribeReplaceRootVolumeTasksOutput, error)) *EC2_DescribeReplaceRootVolumeTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeReservedInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeReservedInstances(ctx context.Context, params *ec2.DescribeReservedInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeReservedInstances")
	}

	var r0 *ec2.DescribeReservedInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesInput, ...func(*ec2.Options)) *ec2.DescribeReservedInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeReservedInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeReservedInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeReservedInstances'
type EC2_DescribeReservedInstances_Call struct {
	*mock.Call
}

// DescribeReservedInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeReservedInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeReservedInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeReservedInstances_Call {
	return &EC2_DescribeReservedInstances_Call{Call: _e.mock.On("DescribeReservedInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeReservedInstances_Call) Run(run func(ctx context.Context, params *ec2.DescribeReservedInstancesInput, optFns ...func(*ec2.Options))) *EC2_DescribeReservedInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeReservedInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeReservedInstances_Call) Return(_a0 *ec2.DescribeReservedInstancesOutput, _a1 error) *EC2_DescribeReservedInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeReservedInstances_Call) RunAndReturn(run func(context.Context, *ec2.DescribeReservedInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesOutput, error)) *EC2_DescribeReservedInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeReservedInstancesListings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeReservedInstancesListings(ctx context.Context, params *ec2.DescribeReservedInstancesListingsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesListingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeReservedInstancesListings")
	}

	var r0 *ec2.DescribeReservedInstancesListingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesListingsInput, ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesListingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesListingsInput, ...func(*ec2.Options)) *ec2.DescribeReservedInstancesListingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesListingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeReservedInstancesListingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeReservedInstancesListings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeReservedInstancesListings'
type EC2_DescribeReservedInstancesListings_Call struct {
	*mock.Call
}

// DescribeReservedInstancesListings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeReservedInstancesListingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeReservedInstancesListings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeReservedInstancesListings_Call {
	return &EC2_DescribeReservedInstancesListings_Call{Call: _e.mock.On("DescribeReservedInstancesListings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeReservedInstancesListings_Call) Run(run func(ctx context.Context, params *ec2.DescribeReservedInstancesListingsInput, optFns ...func(*ec2.Options))) *EC2_DescribeReservedInstancesListings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeReservedInstancesListingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeReservedInstancesListings_Call) Return(_a0 *ec2.DescribeReservedInstancesListingsOutput, _a1 error) *EC2_DescribeReservedInstancesListings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeReservedInstancesListings_Call) RunAndReturn(run func(context.Context, *ec2.DescribeReservedInstancesListingsInput, ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesListingsOutput, error)) *EC2_DescribeReservedInstancesListings_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeReservedInstancesModifications provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeReservedInstancesModifications(ctx context.Context, params *ec2.DescribeReservedInstancesModificationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesModificationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeReservedInstancesModifications")
	}

	var r0 *ec2.DescribeReservedInstancesModificationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesModificationsInput, ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesModificationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesModificationsInput, ...func(*ec2.Options)) *ec2.DescribeReservedInstancesModificationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesModificationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeReservedInstancesModificationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeReservedInstancesModifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeReservedInstancesModifications'
type EC2_DescribeReservedInstancesModifications_Call struct {
	*mock.Call
}

// DescribeReservedInstancesModifications is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeReservedInstancesModificationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeReservedInstancesModifications(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeReservedInstancesModifications_Call {
	return &EC2_DescribeReservedInstancesModifications_Call{Call: _e.mock.On("DescribeReservedInstancesModifications",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeReservedInstancesModifications_Call) Run(run func(ctx context.Context, params *ec2.DescribeReservedInstancesModificationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeReservedInstancesModifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeReservedInstancesModificationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeReservedInstancesModifications_Call) Return(_a0 *ec2.DescribeReservedInstancesModificationsOutput, _a1 error) *EC2_DescribeReservedInstancesModifications_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeReservedInstancesModifications_Call) RunAndReturn(run func(context.Context, *ec2.DescribeReservedInstancesModificationsInput, ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesModificationsOutput, error)) *EC2_DescribeReservedInstancesModifications_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeReservedInstancesOfferings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeReservedInstancesOfferings(ctx context.Context, params *ec2.DescribeReservedInstancesOfferingsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesOfferingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeReservedInstancesOfferings")
	}

	var r0 *ec2.DescribeReservedInstancesOfferingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesOfferingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeReservedInstancesOfferingsInput, ...func(*ec2.Options)) *ec2.DescribeReservedInstancesOfferingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeReservedInstancesOfferingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeReservedInstancesOfferingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeReservedInstancesOfferings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeReservedInstancesOfferings'
type EC2_DescribeReservedInstancesOfferings_Call struct {
	*mock.Call
}

// DescribeReservedInstancesOfferings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeReservedInstancesOfferingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeReservedInstancesOfferings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeReservedInstancesOfferings_Call {
	return &EC2_DescribeReservedInstancesOfferings_Call{Call: _e.mock.On("DescribeReservedInstancesOfferings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeReservedInstancesOfferings_Call) Run(run func(ctx context.Context, params *ec2.DescribeReservedInstancesOfferingsInput, optFns ...func(*ec2.Options))) *EC2_DescribeReservedInstancesOfferings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeReservedInstancesOfferingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeReservedInstancesOfferings_Call) Return(_a0 *ec2.DescribeReservedInstancesOfferingsOutput, _a1 error) *EC2_DescribeReservedInstancesOfferings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeReservedInstancesOfferings_Call) RunAndReturn(run func(context.Context, *ec2.DescribeReservedInstancesOfferingsInput, ...func(*ec2.Options)) (*ec2.DescribeReservedInstancesOfferingsOutput, error)) *EC2_DescribeReservedInstancesOfferings_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeRouteServerEndpoints provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeRouteServerEndpoints(ctx context.Context, params *ec2.DescribeRouteServerEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeRouteServerEndpointsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeRouteServerEndpoints")
	}

	var r0 *ec2.DescribeRouteServerEndpointsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteServerEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeRouteServerEndpointsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteServerEndpointsInput, ...func(*ec2.Options)) *ec2.DescribeRouteServerEndpointsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRouteServerEndpointsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeRouteServerEndpointsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeRouteServerEndpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeRouteServerEndpoints'
type EC2_DescribeRouteServerEndpoints_Call struct {
	*mock.Call
}

// DescribeRouteServerEndpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeRouteServerEndpointsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeRouteServerEndpoints(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeRouteServerEndpoints_Call {
	return &EC2_DescribeRouteServerEndpoints_Call{Call: _e.mock.On("DescribeRouteServerEndpoints",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeRouteServerEndpoints_Call) Run(run func(ctx context.Context, params *ec2.DescribeRouteServerEndpointsInput, optFns ...func(*ec2.Options))) *EC2_DescribeRouteServerEndpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeRouteServerEndpointsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeRouteServerEndpoints_Call) Return(_a0 *ec2.DescribeRouteServerEndpointsOutput, _a1 error) *EC2_DescribeRouteServerEndpoints_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeRouteServerEndpoints_Call) RunAndReturn(run func(context.Context, *ec2.DescribeRouteServerEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeRouteServerEndpointsOutput, error)) *EC2_DescribeRouteServerEndpoints_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeRouteServerPeers provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeRouteServerPeers(ctx context.Context, params *ec2.DescribeRouteServerPeersInput, optFns ...func(*ec2.Options)) (*ec2.DescribeRouteServerPeersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeRouteServerPeers")
	}

	var r0 *ec2.DescribeRouteServerPeersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteServerPeersInput, ...func(*ec2.Options)) (*ec2.DescribeRouteServerPeersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteServerPeersInput, ...func(*ec2.Options)) *ec2.DescribeRouteServerPeersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRouteServerPeersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeRouteServerPeersInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeRouteServerPeers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeRouteServerPeers'
type EC2_DescribeRouteServerPeers_Call struct {
	*mock.Call
}

// DescribeRouteServerPeers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeRouteServerPeersInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeRouteServerPeers(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeRouteServerPeers_Call {
	return &EC2_DescribeRouteServerPeers_Call{Call: _e.mock.On("DescribeRouteServerPeers",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeRouteServerPeers_Call) Run(run func(ctx context.Context, params *ec2.DescribeRouteServerPeersInput, optFns ...func(*ec2.Options))) *EC2_DescribeRouteServerPeers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeRouteServerPeersInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeRouteServerPeers_Call) Return(_a0 *ec2.DescribeRouteServerPeersOutput, _a1 error) *EC2_DescribeRouteServerPeers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeRouteServerPeers_Call) RunAndReturn(run func(context.Context, *ec2.DescribeRouteServerPeersInput, ...func(*ec2.Options)) (*ec2.DescribeRouteServerPeersOutput, error)) *EC2_DescribeRouteServerPeers_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeRouteServers provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeRouteServers(ctx context.Context, params *ec2.DescribeRouteServersInput, optFns ...func(*ec2.Options)) (*ec2.DescribeRouteServersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeRouteServers")
	}

	var r0 *ec2.DescribeRouteServersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteServersInput, ...func(*ec2.Options)) (*ec2.DescribeRouteServersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteServersInput, ...func(*ec2.Options)) *ec2.DescribeRouteServersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRouteServersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeRouteServersInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeRouteServers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeRouteServers'
type EC2_DescribeRouteServers_Call struct {
	*mock.Call
}

// DescribeRouteServers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeRouteServersInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeRouteServers(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeRouteServers_Call {
	return &EC2_DescribeRouteServers_Call{Call: _e.mock.On("DescribeRouteServers",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeRouteServers_Call) Run(run func(ctx context.Context, params *ec2.DescribeRouteServersInput, optFns ...func(*ec2.Options))) *EC2_DescribeRouteServers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeRouteServersInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeRouteServers_Call) Return(_a0 *ec2.DescribeRouteServersOutput, _a1 error) *EC2_DescribeRouteServers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeRouteServers_Call) RunAndReturn(run func(context.Context, *ec2.DescribeRouteServersInput, ...func(*ec2.Options)) (*ec2.DescribeRouteServersOutput, error)) *EC2_DescribeRouteServers_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeRouteTables provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeRouteTables(ctx context.Context, params *ec2.DescribeRouteTablesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeRouteTablesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeRouteTables")
	}

	var r0 *ec2.DescribeRouteTablesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteTablesInput, ...func(*ec2.Options)) (*ec2.DescribeRouteTablesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeRouteTablesInput, ...func(*ec2.Options)) *ec2.DescribeRouteTablesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeRouteTablesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeRouteTablesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeRouteTables_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeRouteTables'
type EC2_DescribeRouteTables_Call struct {
	*mock.Call
}

// DescribeRouteTables is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeRouteTablesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeRouteTables(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeRouteTables_Call {
	return &EC2_DescribeRouteTables_Call{Call: _e.mock.On("DescribeRouteTables",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeRouteTables_Call) Run(run func(ctx context.Context, params *ec2.DescribeRouteTablesInput, optFns ...func(*ec2.Options))) *EC2_DescribeRouteTables_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeRouteTablesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeRouteTables_Call) Return(_a0 *ec2.DescribeRouteTablesOutput, _a1 error) *EC2_DescribeRouteTables_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeRouteTables_Call) RunAndReturn(run func(context.Context, *ec2.DescribeRouteTablesInput, ...func(*ec2.Options)) (*ec2.DescribeRouteTablesOutput, error)) *EC2_DescribeRouteTables_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeScheduledInstanceAvailability provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeScheduledInstanceAvailability(ctx context.Context, params *ec2.DescribeScheduledInstanceAvailabilityInput, optFns ...func(*ec2.Options)) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeScheduledInstanceAvailability")
	}

	var r0 *ec2.DescribeScheduledInstanceAvailabilityOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeScheduledInstanceAvailabilityInput, ...func(*ec2.Options)) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeScheduledInstanceAvailabilityInput, ...func(*ec2.Options)) *ec2.DescribeScheduledInstanceAvailabilityOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeScheduledInstanceAvailabilityOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeScheduledInstanceAvailabilityInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeScheduledInstanceAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeScheduledInstanceAvailability'
type EC2_DescribeScheduledInstanceAvailability_Call struct {
	*mock.Call
}

// DescribeScheduledInstanceAvailability is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeScheduledInstanceAvailabilityInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeScheduledInstanceAvailability(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeScheduledInstanceAvailability_Call {
	return &EC2_DescribeScheduledInstanceAvailability_Call{Call: _e.mock.On("DescribeScheduledInstanceAvailability",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeScheduledInstanceAvailability_Call) Run(run func(ctx context.Context, params *ec2.DescribeScheduledInstanceAvailabilityInput, optFns ...func(*ec2.Options))) *EC2_DescribeScheduledInstanceAvailability_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeScheduledInstanceAvailabilityInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeScheduledInstanceAvailability_Call) Return(_a0 *ec2.DescribeScheduledInstanceAvailabilityOutput, _a1 error) *EC2_DescribeScheduledInstanceAvailability_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeScheduledInstanceAvailability_Call) RunAndReturn(run func(context.Context, *ec2.DescribeScheduledInstanceAvailabilityInput, ...func(*ec2.Options)) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error)) *EC2_DescribeScheduledInstanceAvailability_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeScheduledInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeScheduledInstances(ctx context.Context, params *ec2.DescribeScheduledInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeScheduledInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeScheduledInstances")
	}

	var r0 *ec2.DescribeScheduledInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeScheduledInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeScheduledInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeScheduledInstancesInput, ...func(*ec2.Options)) *ec2.DescribeScheduledInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeScheduledInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeScheduledInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeScheduledInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeScheduledInstances'
type EC2_DescribeScheduledInstances_Call struct {
	*mock.Call
}

// DescribeScheduledInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeScheduledInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeScheduledInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeScheduledInstances_Call {
	return &EC2_DescribeScheduledInstances_Call{Call: _e.mock.On("DescribeScheduledInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeScheduledInstances_Call) Run(run func(ctx context.Context, params *ec2.DescribeScheduledInstancesInput, optFns ...func(*ec2.Options))) *EC2_DescribeScheduledInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeScheduledInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeScheduledInstances_Call) Return(_a0 *ec2.DescribeScheduledInstancesOutput, _a1 error) *EC2_DescribeScheduledInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeScheduledInstances_Call) RunAndReturn(run func(context.Context, *ec2.DescribeScheduledInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeScheduledInstancesOutput, error)) *EC2_DescribeScheduledInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSecurityGroupReferences provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSecurityGroupReferences(ctx context.Context, params *ec2.DescribeSecurityGroupReferencesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupReferencesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSecurityGroupReferences")
	}

	var r0 *ec2.DescribeSecurityGroupReferencesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupReferencesInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupReferencesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupReferencesInput, ...func(*ec2.Options)) *ec2.DescribeSecurityGroupReferencesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSecurityGroupReferencesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSecurityGroupReferencesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSecurityGroupReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSecurityGroupReferences'
type EC2_DescribeSecurityGroupReferences_Call struct {
	*mock.Call
}

// DescribeSecurityGroupReferences is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSecurityGroupReferencesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSecurityGroupReferences(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSecurityGroupReferences_Call {
	return &EC2_DescribeSecurityGroupReferences_Call{Call: _e.mock.On("DescribeSecurityGroupReferences",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSecurityGroupReferences_Call) Run(run func(ctx context.Context, params *ec2.DescribeSecurityGroupReferencesInput, optFns ...func(*ec2.Options))) *EC2_DescribeSecurityGroupReferences_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSecurityGroupReferencesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSecurityGroupReferences_Call) Return(_a0 *ec2.DescribeSecurityGroupReferencesOutput, _a1 error) *EC2_DescribeSecurityGroupReferences_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSecurityGroupReferences_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSecurityGroupReferencesInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupReferencesOutput, error)) *EC2_DescribeSecurityGroupReferences_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSecurityGroupRules provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSecurityGroupRules(ctx context.Context, params *ec2.DescribeSecurityGroupRulesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupRulesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSecurityGroupRules")
	}

	var r0 *ec2.DescribeSecurityGroupRulesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupRulesInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupRulesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupRulesInput, ...func(*ec2.Options)) *ec2.DescribeSecurityGroupRulesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSecurityGroupRulesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSecurityGroupRulesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSecurityGroupRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSecurityGroupRules'
type EC2_DescribeSecurityGroupRules_Call struct {
	*mock.Call
}

// DescribeSecurityGroupRules is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSecurityGroupRulesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSecurityGroupRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSecurityGroupRules_Call {
	return &EC2_DescribeSecurityGroupRules_Call{Call: _e.mock.On("DescribeSecurityGroupRules",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSecurityGroupRules_Call) Run(run func(ctx context.Context, params *ec2.DescribeSecurityGroupRulesInput, optFns ...func(*ec2.Options))) *EC2_DescribeSecurityGroupRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSecurityGroupRulesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSecurityGroupRules_Call) Return(_a0 *ec2.DescribeSecurityGroupRulesOutput, _a1 error) *EC2_DescribeSecurityGroupRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSecurityGroupRules_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSecurityGroupRulesInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupRulesOutput, error)) *EC2_DescribeSecurityGroupRules_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSecurityGroupVpcAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSecurityGroupVpcAssociations(ctx context.Context, params *ec2.DescribeSecurityGroupVpcAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupVpcAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSecurityGroupVpcAssociations")
	}

	var r0 *ec2.DescribeSecurityGroupVpcAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupVpcAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupVpcAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupVpcAssociationsInput, ...func(*ec2.Options)) *ec2.DescribeSecurityGroupVpcAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSecurityGroupVpcAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSecurityGroupVpcAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSecurityGroupVpcAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSecurityGroupVpcAssociations'
type EC2_DescribeSecurityGroupVpcAssociations_Call struct {
	*mock.Call
}

// DescribeSecurityGroupVpcAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSecurityGroupVpcAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSecurityGroupVpcAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSecurityGroupVpcAssociations_Call {
	return &EC2_DescribeSecurityGroupVpcAssociations_Call{Call: _e.mock.On("DescribeSecurityGroupVpcAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSecurityGroupVpcAssociations_Call) Run(run func(ctx context.Context, params *ec2.DescribeSecurityGroupVpcAssociationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeSecurityGroupVpcAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSecurityGroupVpcAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSecurityGroupVpcAssociations_Call) Return(_a0 *ec2.DescribeSecurityGroupVpcAssociationsOutput, _a1 error) *EC2_DescribeSecurityGroupVpcAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSecurityGroupVpcAssociations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSecurityGroupVpcAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupVpcAssociationsOutput, error)) *EC2_DescribeSecurityGroupVpcAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSecurityGroups provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSecurityGroups(ctx context.Context, params *ec2.DescribeSecurityGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSecurityGroups")
	}

	var r0 *ec2.DescribeSecurityGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSecurityGroupsInput, ...func(*ec2.Options)) *ec2.DescribeSecurityGroupsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSecurityGroupsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSecurityGroupsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSecurityGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSecurityGroups'
type EC2_DescribeSecurityGroups_Call struct {
	*mock.Call
}

// DescribeSecurityGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSecurityGroupsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSecurityGroups(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSecurityGroups_Call {
	return &EC2_DescribeSecurityGroups_Call{Call: _e.mock.On("DescribeSecurityGroups",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSecurityGroups_Call) Run(run func(ctx context.Context, params *ec2.DescribeSecurityGroupsInput, optFns ...func(*ec2.Options))) *EC2_DescribeSecurityGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSecurityGroupsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSecurityGroups_Call) Return(_a0 *ec2.DescribeSecurityGroupsOutput, _a1 error) *EC2_DescribeSecurityGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSecurityGroups_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSecurityGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupsOutput, error)) *EC2_DescribeSecurityGroups_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeServiceLinkVirtualInterfaces provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeServiceLinkVirtualInterfaces(ctx context.Context, params *ec2.DescribeServiceLinkVirtualInterfacesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeServiceLinkVirtualInterfacesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeServiceLinkVirtualInterfaces")
	}

	var r0 *ec2.DescribeServiceLinkVirtualInterfacesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeServiceLinkVirtualInterfacesInput, ...func(*ec2.Options)) (*ec2.DescribeServiceLinkVirtualInterfacesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeServiceLinkVirtualInterfacesInput, ...func(*ec2.Options)) *ec2.DescribeServiceLinkVirtualInterfacesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeServiceLinkVirtualInterfacesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeServiceLinkVirtualInterfacesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeServiceLinkVirtualInterfaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeServiceLinkVirtualInterfaces'
type EC2_DescribeServiceLinkVirtualInterfaces_Call struct {
	*mock.Call
}

// DescribeServiceLinkVirtualInterfaces is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeServiceLinkVirtualInterfacesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeServiceLinkVirtualInterfaces(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeServiceLinkVirtualInterfaces_Call {
	return &EC2_DescribeServiceLinkVirtualInterfaces_Call{Call: _e.mock.On("DescribeServiceLinkVirtualInterfaces",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeServiceLinkVirtualInterfaces_Call) Run(run func(ctx context.Context, params *ec2.DescribeServiceLinkVirtualInterfacesInput, optFns ...func(*ec2.Options))) *EC2_DescribeServiceLinkVirtualInterfaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeServiceLinkVirtualInterfacesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeServiceLinkVirtualInterfaces_Call) Return(_a0 *ec2.DescribeServiceLinkVirtualInterfacesOutput, _a1 error) *EC2_DescribeServiceLinkVirtualInterfaces_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeServiceLinkVirtualInterfaces_Call) RunAndReturn(run func(context.Context, *ec2.DescribeServiceLinkVirtualInterfacesInput, ...func(*ec2.Options)) (*ec2.DescribeServiceLinkVirtualInterfacesOutput, error)) *EC2_DescribeServiceLinkVirtualInterfaces_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSnapshotAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSnapshotAttribute(ctx context.Context, params *ec2.DescribeSnapshotAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSnapshotAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSnapshotAttribute")
	}

	var r0 *ec2.DescribeSnapshotAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSnapshotAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeSnapshotAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSnapshotAttributeInput, ...func(*ec2.Options)) *ec2.DescribeSnapshotAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSnapshotAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSnapshotAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSnapshotAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSnapshotAttribute'
type EC2_DescribeSnapshotAttribute_Call struct {
	*mock.Call
}

// DescribeSnapshotAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSnapshotAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSnapshotAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSnapshotAttribute_Call {
	return &EC2_DescribeSnapshotAttribute_Call{Call: _e.mock.On("DescribeSnapshotAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSnapshotAttribute_Call) Run(run func(ctx context.Context, params *ec2.DescribeSnapshotAttributeInput, optFns ...func(*ec2.Options))) *EC2_DescribeSnapshotAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSnapshotAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSnapshotAttribute_Call) Return(_a0 *ec2.DescribeSnapshotAttributeOutput, _a1 error) *EC2_DescribeSnapshotAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSnapshotAttribute_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSnapshotAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeSnapshotAttributeOutput, error)) *EC2_DescribeSnapshotAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSnapshotTierStatus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSnapshotTierStatus(ctx context.Context, params *ec2.DescribeSnapshotTierStatusInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSnapshotTierStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSnapshotTierStatus")
	}

	var r0 *ec2.DescribeSnapshotTierStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSnapshotTierStatusInput, ...func(*ec2.Options)) (*ec2.DescribeSnapshotTierStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSnapshotTierStatusInput, ...func(*ec2.Options)) *ec2.DescribeSnapshotTierStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSnapshotTierStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSnapshotTierStatusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSnapshotTierStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSnapshotTierStatus'
type EC2_DescribeSnapshotTierStatus_Call struct {
	*mock.Call
}

// DescribeSnapshotTierStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSnapshotTierStatusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSnapshotTierStatus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSnapshotTierStatus_Call {
	return &EC2_DescribeSnapshotTierStatus_Call{Call: _e.mock.On("DescribeSnapshotTierStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSnapshotTierStatus_Call) Run(run func(ctx context.Context, params *ec2.DescribeSnapshotTierStatusInput, optFns ...func(*ec2.Options))) *EC2_DescribeSnapshotTierStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSnapshotTierStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSnapshotTierStatus_Call) Return(_a0 *ec2.DescribeSnapshotTierStatusOutput, _a1 error) *EC2_DescribeSnapshotTierStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSnapshotTierStatus_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSnapshotTierStatusInput, ...func(*ec2.Options)) (*ec2.DescribeSnapshotTierStatusOutput, error)) *EC2_DescribeSnapshotTierStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSnapshots provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSnapshots(ctx context.Context, params *ec2.DescribeSnapshotsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSnapshotsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSnapshots")
	}

	var r0 *ec2.DescribeSnapshotsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSnapshotsInput, ...func(*ec2.Options)) (*ec2.DescribeSnapshotsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSnapshotsInput, ...func(*ec2.Options)) *ec2.DescribeSnapshotsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSnapshotsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSnapshotsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSnapshots'
type EC2_DescribeSnapshots_Call struct {
	*mock.Call
}

// DescribeSnapshots is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSnapshotsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSnapshots(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSnapshots_Call {
	return &EC2_DescribeSnapshots_Call{Call: _e.mock.On("DescribeSnapshots",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSnapshots_Call) Run(run func(ctx context.Context, params *ec2.DescribeSnapshotsInput, optFns ...func(*ec2.Options))) *EC2_DescribeSnapshots_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSnapshotsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSnapshots_Call) Return(_a0 *ec2.DescribeSnapshotsOutput, _a1 error) *EC2_DescribeSnapshots_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSnapshots_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSnapshotsInput, ...func(*ec2.Options)) (*ec2.DescribeSnapshotsOutput, error)) *EC2_DescribeSnapshots_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSpotDatafeedSubscription provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSpotDatafeedSubscription(ctx context.Context, params *ec2.DescribeSpotDatafeedSubscriptionInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSpotDatafeedSubscription")
	}

	var r0 *ec2.DescribeSpotDatafeedSubscriptionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) *ec2.DescribeSpotDatafeedSubscriptionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotDatafeedSubscriptionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSpotDatafeedSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSpotDatafeedSubscription'
type EC2_DescribeSpotDatafeedSubscription_Call struct {
	*mock.Call
}

// DescribeSpotDatafeedSubscription is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSpotDatafeedSubscriptionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSpotDatafeedSubscription(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSpotDatafeedSubscription_Call {
	return &EC2_DescribeSpotDatafeedSubscription_Call{Call: _e.mock.On("DescribeSpotDatafeedSubscription",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSpotDatafeedSubscription_Call) Run(run func(ctx context.Context, params *ec2.DescribeSpotDatafeedSubscriptionInput, optFns ...func(*ec2.Options))) *EC2_DescribeSpotDatafeedSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSpotDatafeedSubscriptionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSpotDatafeedSubscription_Call) Return(_a0 *ec2.DescribeSpotDatafeedSubscriptionOutput, _a1 error) *EC2_DescribeSpotDatafeedSubscription_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSpotDatafeedSubscription_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSpotDatafeedSubscriptionInput, ...func(*ec2.Options)) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error)) *EC2_DescribeSpotDatafeedSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSpotFleetInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSpotFleetInstances(ctx context.Context, params *ec2.DescribeSpotFleetInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSpotFleetInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSpotFleetInstances")
	}

	var r0 *ec2.DescribeSpotFleetInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeSpotFleetInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetInstancesInput, ...func(*ec2.Options)) *ec2.DescribeSpotFleetInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotFleetInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSpotFleetInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSpotFleetInstances'
type EC2_DescribeSpotFleetInstances_Call struct {
	*mock.Call
}

// DescribeSpotFleetInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSpotFleetInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSpotFleetInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSpotFleetInstances_Call {
	return &EC2_DescribeSpotFleetInstances_Call{Call: _e.mock.On("DescribeSpotFleetInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSpotFleetInstances_Call) Run(run func(ctx context.Context, params *ec2.DescribeSpotFleetInstancesInput, optFns ...func(*ec2.Options))) *EC2_DescribeSpotFleetInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSpotFleetInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSpotFleetInstances_Call) Return(_a0 *ec2.DescribeSpotFleetInstancesOutput, _a1 error) *EC2_DescribeSpotFleetInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSpotFleetInstances_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSpotFleetInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeSpotFleetInstancesOutput, error)) *EC2_DescribeSpotFleetInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSpotFleetRequestHistory provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSpotFleetRequestHistory(ctx context.Context, params *ec2.DescribeSpotFleetRequestHistoryInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSpotFleetRequestHistory")
	}

	var r0 *ec2.DescribeSpotFleetRequestHistoryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetRequestHistoryInput, ...func(*ec2.Options)) (*ec2.DescribeSpotFleetRequestHistoryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetRequestHistoryInput, ...func(*ec2.Options)) *ec2.DescribeSpotFleetRequestHistoryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetRequestHistoryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotFleetRequestHistoryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSpotFleetRequestHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSpotFleetRequestHistory'
type EC2_DescribeSpotFleetRequestHistory_Call struct {
	*mock.Call
}

// DescribeSpotFleetRequestHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSpotFleetRequestHistoryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSpotFleetRequestHistory(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSpotFleetRequestHistory_Call {
	return &EC2_DescribeSpotFleetRequestHistory_Call{Call: _e.mock.On("DescribeSpotFleetRequestHistory",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSpotFleetRequestHistory_Call) Run(run func(ctx context.Context, params *ec2.DescribeSpotFleetRequestHistoryInput, optFns ...func(*ec2.Options))) *EC2_DescribeSpotFleetRequestHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSpotFleetRequestHistoryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSpotFleetRequestHistory_Call) Return(_a0 *ec2.DescribeSpotFleetRequestHistoryOutput, _a1 error) *EC2_DescribeSpotFleetRequestHistory_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSpotFleetRequestHistory_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSpotFleetRequestHistoryInput, ...func(*ec2.Options)) (*ec2.DescribeSpotFleetRequestHistoryOutput, error)) *EC2_DescribeSpotFleetRequestHistory_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSpotFleetRequests provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSpotFleetRequests(ctx context.Context, params *ec2.DescribeSpotFleetRequestsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSpotFleetRequestsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSpotFleetRequests")
	}

	var r0 *ec2.DescribeSpotFleetRequestsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetRequestsInput, ...func(*ec2.Options)) (*ec2.DescribeSpotFleetRequestsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotFleetRequestsInput, ...func(*ec2.Options)) *ec2.DescribeSpotFleetRequestsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotFleetRequestsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotFleetRequestsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSpotFleetRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSpotFleetRequests'
type EC2_DescribeSpotFleetRequests_Call struct {
	*mock.Call
}

// DescribeSpotFleetRequests is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSpotFleetRequestsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSpotFleetRequests(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSpotFleetRequests_Call {
	return &EC2_DescribeSpotFleetRequests_Call{Call: _e.mock.On("DescribeSpotFleetRequests",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSpotFleetRequests_Call) Run(run func(ctx context.Context, params *ec2.DescribeSpotFleetRequestsInput, optFns ...func(*ec2.Options))) *EC2_DescribeSpotFleetRequests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSpotFleetRequestsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSpotFleetRequests_Call) Return(_a0 *ec2.DescribeSpotFleetRequestsOutput, _a1 error) *EC2_DescribeSpotFleetRequests_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSpotFleetRequests_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSpotFleetRequestsInput, ...func(*ec2.Options)) (*ec2.DescribeSpotFleetRequestsOutput, error)) *EC2_DescribeSpotFleetRequests_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSpotInstanceRequests provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSpotInstanceRequests(ctx context.Context, params *ec2.DescribeSpotInstanceRequestsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSpotInstanceRequestsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSpotInstanceRequests")
	}

	var r0 *ec2.DescribeSpotInstanceRequestsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotInstanceRequestsInput, ...func(*ec2.Options)) (*ec2.DescribeSpotInstanceRequestsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotInstanceRequestsInput, ...func(*ec2.Options)) *ec2.DescribeSpotInstanceRequestsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotInstanceRequestsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotInstanceRequestsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSpotInstanceRequests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSpotInstanceRequests'
type EC2_DescribeSpotInstanceRequests_Call struct {
	*mock.Call
}

// DescribeSpotInstanceRequests is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSpotInstanceRequestsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSpotInstanceRequests(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSpotInstanceRequests_Call {
	return &EC2_DescribeSpotInstanceRequests_Call{Call: _e.mock.On("DescribeSpotInstanceRequests",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSpotInstanceRequests_Call) Run(run func(ctx context.Context, params *ec2.DescribeSpotInstanceRequestsInput, optFns ...func(*ec2.Options))) *EC2_DescribeSpotInstanceRequests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSpotInstanceRequestsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSpotInstanceRequests_Call) Return(_a0 *ec2.DescribeSpotInstanceRequestsOutput, _a1 error) *EC2_DescribeSpotInstanceRequests_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSpotInstanceRequests_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSpotInstanceRequestsInput, ...func(*ec2.Options)) (*ec2.DescribeSpotInstanceRequestsOutput, error)) *EC2_DescribeSpotInstanceRequests_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSpotPriceHistory provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSpotPriceHistory(ctx context.Context, params *ec2.DescribeSpotPriceHistoryInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSpotPriceHistoryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSpotPriceHistory")
	}

	var r0 *ec2.DescribeSpotPriceHistoryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotPriceHistoryInput, ...func(*ec2.Options)) (*ec2.DescribeSpotPriceHistoryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSpotPriceHistoryInput, ...func(*ec2.Options)) *ec2.DescribeSpotPriceHistoryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSpotPriceHistoryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSpotPriceHistoryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSpotPriceHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSpotPriceHistory'
type EC2_DescribeSpotPriceHistory_Call struct {
	*mock.Call
}

// DescribeSpotPriceHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSpotPriceHistoryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSpotPriceHistory(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSpotPriceHistory_Call {
	return &EC2_DescribeSpotPriceHistory_Call{Call: _e.mock.On("DescribeSpotPriceHistory",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSpotPriceHistory_Call) Run(run func(ctx context.Context, params *ec2.DescribeSpotPriceHistoryInput, optFns ...func(*ec2.Options))) *EC2_DescribeSpotPriceHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSpotPriceHistoryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSpotPriceHistory_Call) Return(_a0 *ec2.DescribeSpotPriceHistoryOutput, _a1 error) *EC2_DescribeSpotPriceHistory_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSpotPriceHistory_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSpotPriceHistoryInput, ...func(*ec2.Options)) (*ec2.DescribeSpotPriceHistoryOutput, error)) *EC2_DescribeSpotPriceHistory_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStaleSecurityGroups provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeStaleSecurityGroups(ctx context.Context, params *ec2.DescribeStaleSecurityGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeStaleSecurityGroupsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStaleSecurityGroups")
	}

	var r0 *ec2.DescribeStaleSecurityGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeStaleSecurityGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeStaleSecurityGroupsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeStaleSecurityGroupsInput, ...func(*ec2.Options)) *ec2.DescribeStaleSecurityGroupsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeStaleSecurityGroupsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeStaleSecurityGroupsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeStaleSecurityGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStaleSecurityGroups'
type EC2_DescribeStaleSecurityGroups_Call struct {
	*mock.Call
}

// DescribeStaleSecurityGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeStaleSecurityGroupsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeStaleSecurityGroups(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeStaleSecurityGroups_Call {
	return &EC2_DescribeStaleSecurityGroups_Call{Call: _e.mock.On("DescribeStaleSecurityGroups",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeStaleSecurityGroups_Call) Run(run func(ctx context.Context, params *ec2.DescribeStaleSecurityGroupsInput, optFns ...func(*ec2.Options))) *EC2_DescribeStaleSecurityGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeStaleSecurityGroupsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeStaleSecurityGroups_Call) Return(_a0 *ec2.DescribeStaleSecurityGroupsOutput, _a1 error) *EC2_DescribeStaleSecurityGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeStaleSecurityGroups_Call) RunAndReturn(run func(context.Context, *ec2.DescribeStaleSecurityGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeStaleSecurityGroupsOutput, error)) *EC2_DescribeStaleSecurityGroups_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStoreImageTasks provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeStoreImageTasks(ctx context.Context, params *ec2.DescribeStoreImageTasksInput, optFns ...func(*ec2.Options)) (*ec2.DescribeStoreImageTasksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStoreImageTasks")
	}

	var r0 *ec2.DescribeStoreImageTasksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeStoreImageTasksInput, ...func(*ec2.Options)) (*ec2.DescribeStoreImageTasksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeStoreImageTasksInput, ...func(*ec2.Options)) *ec2.DescribeStoreImageTasksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeStoreImageTasksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeStoreImageTasksInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeStoreImageTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStoreImageTasks'
type EC2_DescribeStoreImageTasks_Call struct {
	*mock.Call
}

// DescribeStoreImageTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeStoreImageTasksInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeStoreImageTasks(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeStoreImageTasks_Call {
	return &EC2_DescribeStoreImageTasks_Call{Call: _e.mock.On("DescribeStoreImageTasks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeStoreImageTasks_Call) Run(run func(ctx context.Context, params *ec2.DescribeStoreImageTasksInput, optFns ...func(*ec2.Options))) *EC2_DescribeStoreImageTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeStoreImageTasksInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeStoreImageTasks_Call) Return(_a0 *ec2.DescribeStoreImageTasksOutput, _a1 error) *EC2_DescribeStoreImageTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeStoreImageTasks_Call) RunAndReturn(run func(context.Context, *ec2.DescribeStoreImageTasksInput, ...func(*ec2.Options)) (*ec2.DescribeStoreImageTasksOutput, error)) *EC2_DescribeStoreImageTasks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSubnets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeSubnets(ctx context.Context, params *ec2.DescribeSubnetsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSubnetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeSubnets")
	}

	var r0 *ec2.DescribeSubnetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSubnetsInput, ...func(*ec2.Options)) (*ec2.DescribeSubnetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeSubnetsInput, ...func(*ec2.Options)) *ec2.DescribeSubnetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeSubnetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeSubnetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeSubnets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeSubnets'
type EC2_DescribeSubnets_Call struct {
	*mock.Call
}

// DescribeSubnets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeSubnetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeSubnets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeSubnets_Call {
	return &EC2_DescribeSubnets_Call{Call: _e.mock.On("DescribeSubnets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeSubnets_Call) Run(run func(ctx context.Context, params *ec2.DescribeSubnetsInput, optFns ...func(*ec2.Options))) *EC2_DescribeSubnets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeSubnetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeSubnets_Call) Return(_a0 *ec2.DescribeSubnetsOutput, _a1 error) *EC2_DescribeSubnets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeSubnets_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSubnetsInput, ...func(*ec2.Options)) (*ec2.DescribeSubnetsOutput, error)) *EC2_DescribeSubnets_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTags provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTags(ctx context.Context, params *ec2.DescribeTagsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTagsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTags")
	}

	var r0 *ec2.DescribeTagsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTagsInput, ...func(*ec2.Options)) (*ec2.DescribeTagsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTagsInput, ...func(*ec2.Options)) *ec2.DescribeTagsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTagsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTagsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTags'
type EC2_DescribeTags_Call struct {
	*mock.Call
}

// DescribeTags is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTagsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTags(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTags_Call {
	return &EC2_DescribeTags_Call{Call: _e.mock.On("DescribeTags",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTags_Call) Run(run func(ctx context.Context, params *ec2.DescribeTagsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTagsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTags_Call) Return(_a0 *ec2.DescribeTagsOutput, _a1 error) *EC2_DescribeTags_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTags_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTagsInput, ...func(*ec2.Options)) (*ec2.DescribeTagsOutput, error)) *EC2_DescribeTags_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTrafficMirrorFilterRules provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTrafficMirrorFilterRules(ctx context.Context, params *ec2.DescribeTrafficMirrorFilterRulesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorFilterRulesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTrafficMirrorFilterRules")
	}

	var r0 *ec2.DescribeTrafficMirrorFilterRulesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorFilterRulesInput, ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorFilterRulesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorFilterRulesInput, ...func(*ec2.Options)) *ec2.DescribeTrafficMirrorFilterRulesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorFilterRulesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrafficMirrorFilterRulesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTrafficMirrorFilterRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTrafficMirrorFilterRules'
type EC2_DescribeTrafficMirrorFilterRules_Call struct {
	*mock.Call
}

// DescribeTrafficMirrorFilterRules is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTrafficMirrorFilterRulesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTrafficMirrorFilterRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTrafficMirrorFilterRules_Call {
	return &EC2_DescribeTrafficMirrorFilterRules_Call{Call: _e.mock.On("DescribeTrafficMirrorFilterRules",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTrafficMirrorFilterRules_Call) Run(run func(ctx context.Context, params *ec2.DescribeTrafficMirrorFilterRulesInput, optFns ...func(*ec2.Options))) *EC2_DescribeTrafficMirrorFilterRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTrafficMirrorFilterRulesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTrafficMirrorFilterRules_Call) Return(_a0 *ec2.DescribeTrafficMirrorFilterRulesOutput, _a1 error) *EC2_DescribeTrafficMirrorFilterRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTrafficMirrorFilterRules_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTrafficMirrorFilterRulesInput, ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorFilterRulesOutput, error)) *EC2_DescribeTrafficMirrorFilterRules_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTrafficMirrorFilters provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTrafficMirrorFilters(ctx context.Context, params *ec2.DescribeTrafficMirrorFiltersInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorFiltersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTrafficMirrorFilters")
	}

	var r0 *ec2.DescribeTrafficMirrorFiltersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorFiltersInput, ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorFiltersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorFiltersInput, ...func(*ec2.Options)) *ec2.DescribeTrafficMirrorFiltersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorFiltersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrafficMirrorFiltersInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTrafficMirrorFilters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTrafficMirrorFilters'
type EC2_DescribeTrafficMirrorFilters_Call struct {
	*mock.Call
}

// DescribeTrafficMirrorFilters is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTrafficMirrorFiltersInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTrafficMirrorFilters(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTrafficMirrorFilters_Call {
	return &EC2_DescribeTrafficMirrorFilters_Call{Call: _e.mock.On("DescribeTrafficMirrorFilters",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTrafficMirrorFilters_Call) Run(run func(ctx context.Context, params *ec2.DescribeTrafficMirrorFiltersInput, optFns ...func(*ec2.Options))) *EC2_DescribeTrafficMirrorFilters_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTrafficMirrorFiltersInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTrafficMirrorFilters_Call) Return(_a0 *ec2.DescribeTrafficMirrorFiltersOutput, _a1 error) *EC2_DescribeTrafficMirrorFilters_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTrafficMirrorFilters_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTrafficMirrorFiltersInput, ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorFiltersOutput, error)) *EC2_DescribeTrafficMirrorFilters_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTrafficMirrorSessions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTrafficMirrorSessions(ctx context.Context, params *ec2.DescribeTrafficMirrorSessionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorSessionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTrafficMirrorSessions")
	}

	var r0 *ec2.DescribeTrafficMirrorSessionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorSessionsInput, ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorSessionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorSessionsInput, ...func(*ec2.Options)) *ec2.DescribeTrafficMirrorSessionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorSessionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrafficMirrorSessionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTrafficMirrorSessions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTrafficMirrorSessions'
type EC2_DescribeTrafficMirrorSessions_Call struct {
	*mock.Call
}

// DescribeTrafficMirrorSessions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTrafficMirrorSessionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTrafficMirrorSessions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTrafficMirrorSessions_Call {
	return &EC2_DescribeTrafficMirrorSessions_Call{Call: _e.mock.On("DescribeTrafficMirrorSessions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTrafficMirrorSessions_Call) Run(run func(ctx context.Context, params *ec2.DescribeTrafficMirrorSessionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTrafficMirrorSessions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTrafficMirrorSessionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTrafficMirrorSessions_Call) Return(_a0 *ec2.DescribeTrafficMirrorSessionsOutput, _a1 error) *EC2_DescribeTrafficMirrorSessions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTrafficMirrorSessions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTrafficMirrorSessionsInput, ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorSessionsOutput, error)) *EC2_DescribeTrafficMirrorSessions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTrafficMirrorTargets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTrafficMirrorTargets(ctx context.Context, params *ec2.DescribeTrafficMirrorTargetsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorTargetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTrafficMirrorTargets")
	}

	var r0 *ec2.DescribeTrafficMirrorTargetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorTargetsInput, ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorTargetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrafficMirrorTargetsInput, ...func(*ec2.Options)) *ec2.DescribeTrafficMirrorTargetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrafficMirrorTargetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrafficMirrorTargetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTrafficMirrorTargets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTrafficMirrorTargets'
type EC2_DescribeTrafficMirrorTargets_Call struct {
	*mock.Call
}

// DescribeTrafficMirrorTargets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTrafficMirrorTargetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTrafficMirrorTargets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTrafficMirrorTargets_Call {
	return &EC2_DescribeTrafficMirrorTargets_Call{Call: _e.mock.On("DescribeTrafficMirrorTargets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTrafficMirrorTargets_Call) Run(run func(ctx context.Context, params *ec2.DescribeTrafficMirrorTargetsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTrafficMirrorTargets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTrafficMirrorTargetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTrafficMirrorTargets_Call) Return(_a0 *ec2.DescribeTrafficMirrorTargetsOutput, _a1 error) *EC2_DescribeTrafficMirrorTargets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTrafficMirrorTargets_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTrafficMirrorTargetsInput, ...func(*ec2.Options)) (*ec2.DescribeTrafficMirrorTargetsOutput, error)) *EC2_DescribeTrafficMirrorTargets_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayAttachments provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayAttachments(ctx context.Context, params *ec2.DescribeTransitGatewayAttachmentsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayAttachments")
	}

	var r0 *ec2.DescribeTransitGatewayAttachmentsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayAttachmentsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayAttachmentsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayAttachmentsInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayAttachmentsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayAttachmentsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayAttachmentsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayAttachments'
type EC2_DescribeTransitGatewayAttachments_Call struct {
	*mock.Call
}

// DescribeTransitGatewayAttachments is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayAttachmentsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayAttachments(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayAttachments_Call {
	return &EC2_DescribeTransitGatewayAttachments_Call{Call: _e.mock.On("DescribeTransitGatewayAttachments",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayAttachments_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayAttachmentsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayAttachments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayAttachmentsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayAttachments_Call) Return(_a0 *ec2.DescribeTransitGatewayAttachmentsOutput, _a1 error) *EC2_DescribeTransitGatewayAttachments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayAttachments_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayAttachmentsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayAttachmentsOutput, error)) *EC2_DescribeTransitGatewayAttachments_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayConnectPeers provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayConnectPeers(ctx context.Context, params *ec2.DescribeTransitGatewayConnectPeersInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayConnectPeers")
	}

	var r0 *ec2.DescribeTransitGatewayConnectPeersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayConnectPeersInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayConnectPeersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayConnectPeersInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayConnectPeersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayConnectPeersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayConnectPeersInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayConnectPeers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayConnectPeers'
type EC2_DescribeTransitGatewayConnectPeers_Call struct {
	*mock.Call
}

// DescribeTransitGatewayConnectPeers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayConnectPeersInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayConnectPeers(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayConnectPeers_Call {
	return &EC2_DescribeTransitGatewayConnectPeers_Call{Call: _e.mock.On("DescribeTransitGatewayConnectPeers",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayConnectPeers_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayConnectPeersInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayConnectPeers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayConnectPeersInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayConnectPeers_Call) Return(_a0 *ec2.DescribeTransitGatewayConnectPeersOutput, _a1 error) *EC2_DescribeTransitGatewayConnectPeers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayConnectPeers_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayConnectPeersInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayConnectPeersOutput, error)) *EC2_DescribeTransitGatewayConnectPeers_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayConnects provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayConnects(ctx context.Context, params *ec2.DescribeTransitGatewayConnectsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayConnectsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayConnects")
	}

	var r0 *ec2.DescribeTransitGatewayConnectsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayConnectsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayConnectsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayConnectsInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayConnectsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayConnectsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayConnectsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayConnects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayConnects'
type EC2_DescribeTransitGatewayConnects_Call struct {
	*mock.Call
}

// DescribeTransitGatewayConnects is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayConnectsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayConnects(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayConnects_Call {
	return &EC2_DescribeTransitGatewayConnects_Call{Call: _e.mock.On("DescribeTransitGatewayConnects",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayConnects_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayConnectsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayConnects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayConnectsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayConnects_Call) Return(_a0 *ec2.DescribeTransitGatewayConnectsOutput, _a1 error) *EC2_DescribeTransitGatewayConnects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayConnects_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayConnectsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayConnectsOutput, error)) *EC2_DescribeTransitGatewayConnects_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayMeteringPolicies provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayMeteringPolicies(ctx context.Context, params *ec2.DescribeTransitGatewayMeteringPoliciesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMeteringPoliciesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayMeteringPolicies")
	}

	var r0 *ec2.DescribeTransitGatewayMeteringPoliciesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayMeteringPoliciesInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMeteringPoliciesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayMeteringPoliciesInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayMeteringPoliciesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayMeteringPoliciesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayMeteringPoliciesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayMeteringPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayMeteringPolicies'
type EC2_DescribeTransitGatewayMeteringPolicies_Call struct {
	*mock.Call
}

// DescribeTransitGatewayMeteringPolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayMeteringPoliciesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayMeteringPolicies(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayMeteringPolicies_Call {
	return &EC2_DescribeTransitGatewayMeteringPolicies_Call{Call: _e.mock.On("DescribeTransitGatewayMeteringPolicies",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayMeteringPolicies_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayMeteringPoliciesInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayMeteringPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayMeteringPoliciesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayMeteringPolicies_Call) Return(_a0 *ec2.DescribeTransitGatewayMeteringPoliciesOutput, _a1 error) *EC2_DescribeTransitGatewayMeteringPolicies_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayMeteringPolicies_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayMeteringPoliciesInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMeteringPoliciesOutput, error)) *EC2_DescribeTransitGatewayMeteringPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayMulticastDomains provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayMulticastDomains(ctx context.Context, params *ec2.DescribeTransitGatewayMulticastDomainsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayMulticastDomains")
	}

	var r0 *ec2.DescribeTransitGatewayMulticastDomainsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayMulticastDomainsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayMulticastDomainsInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayMulticastDomainsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayMulticastDomainsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayMulticastDomains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayMulticastDomains'
type EC2_DescribeTransitGatewayMulticastDomains_Call struct {
	*mock.Call
}

// DescribeTransitGatewayMulticastDomains is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayMulticastDomainsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayMulticastDomains(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayMulticastDomains_Call {
	return &EC2_DescribeTransitGatewayMulticastDomains_Call{Call: _e.mock.On("DescribeTransitGatewayMulticastDomains",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayMulticastDomains_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayMulticastDomainsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayMulticastDomains_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayMulticastDomainsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayMulticastDomains_Call) Return(_a0 *ec2.DescribeTransitGatewayMulticastDomainsOutput, _a1 error) *EC2_DescribeTransitGatewayMulticastDomains_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayMulticastDomains_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayMulticastDomainsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error)) *EC2_DescribeTransitGatewayMulticastDomains_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayPeeringAttachments provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayPeeringAttachments(ctx context.Context, params *ec2.DescribeTransitGatewayPeeringAttachmentsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayPeeringAttachments")
	}

	var r0 *ec2.DescribeTransitGatewayPeeringAttachmentsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayPeeringAttachmentsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayPeeringAttachmentsInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayPeeringAttachmentsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayPeeringAttachmentsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayPeeringAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayPeeringAttachments'
type EC2_DescribeTransitGatewayPeeringAttachments_Call struct {
	*mock.Call
}

// DescribeTransitGatewayPeeringAttachments is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayPeeringAttachmentsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayPeeringAttachments(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayPeeringAttachments_Call {
	return &EC2_DescribeTransitGatewayPeeringAttachments_Call{Call: _e.mock.On("DescribeTransitGatewayPeeringAttachments",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayPeeringAttachments_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayPeeringAttachmentsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayPeeringAttachments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayPeeringAttachmentsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayPeeringAttachments_Call) Return(_a0 *ec2.DescribeTransitGatewayPeeringAttachmentsOutput, _a1 error) *EC2_DescribeTransitGatewayPeeringAttachments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayPeeringAttachments_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayPeeringAttachmentsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error)) *EC2_DescribeTransitGatewayPeeringAttachments_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayPolicyTables provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayPolicyTables(ctx context.Context, params *ec2.DescribeTransitGatewayPolicyTablesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayPolicyTables")
	}

	var r0 *ec2.DescribeTransitGatewayPolicyTablesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayPolicyTablesInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayPolicyTablesInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayPolicyTablesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayPolicyTablesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayPolicyTablesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayPolicyTables_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayPolicyTables'
type EC2_DescribeTransitGatewayPolicyTables_Call struct {
	*mock.Call
}

// DescribeTransitGatewayPolicyTables is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayPolicyTablesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayPolicyTables(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayPolicyTables_Call {
	return &EC2_DescribeTransitGatewayPolicyTables_Call{Call: _e.mock.On("DescribeTransitGatewayPolicyTables",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayPolicyTables_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayPolicyTablesInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayPolicyTables_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayPolicyTablesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayPolicyTables_Call) Return(_a0 *ec2.DescribeTransitGatewayPolicyTablesOutput, _a1 error) *EC2_DescribeTransitGatewayPolicyTables_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayPolicyTables_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayPolicyTablesInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error)) *EC2_DescribeTransitGatewayPolicyTables_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayRouteTableAnnouncements provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayRouteTableAnnouncements(ctx context.Context, params *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayRouteTableAnnouncements")
	}

	var r0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayRouteTableAnnouncements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayRouteTableAnnouncements'
type EC2_DescribeTransitGatewayRouteTableAnnouncements_Call struct {
	*mock.Call
}

// DescribeTransitGatewayRouteTableAnnouncements is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayRouteTableAnnouncements(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayRouteTableAnnouncements_Call {
	return &EC2_DescribeTransitGatewayRouteTableAnnouncements_Call{Call: _e.mock.On("DescribeTransitGatewayRouteTableAnnouncements",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayRouteTableAnnouncements_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayRouteTableAnnouncements_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayRouteTableAnnouncements_Call) Return(_a0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, _a1 error) *EC2_DescribeTransitGatewayRouteTableAnnouncements_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayRouteTableAnnouncements_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error)) *EC2_DescribeTransitGatewayRouteTableAnnouncements_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayRouteTables provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayRouteTables(ctx context.Context, params *ec2.DescribeTransitGatewayRouteTablesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayRouteTables")
	}

	var r0 *ec2.DescribeTransitGatewayRouteTablesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayRouteTablesInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayRouteTablesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayRouteTablesInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayRouteTablesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayRouteTablesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayRouteTablesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayRouteTables_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayRouteTables'
type EC2_DescribeTransitGatewayRouteTables_Call struct {
	*mock.Call
}

// DescribeTransitGatewayRouteTables is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayRouteTablesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayRouteTables(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayRouteTables_Call {
	return &EC2_DescribeTransitGatewayRouteTables_Call{Call: _e.mock.On("DescribeTransitGatewayRouteTables",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayRouteTables_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayRouteTablesInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayRouteTables_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayRouteTablesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayRouteTables_Call) Return(_a0 *ec2.DescribeTransitGatewayRouteTablesOutput, _a1 error) *EC2_DescribeTransitGatewayRouteTables_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayRouteTables_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayRouteTablesInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayRouteTablesOutput, error)) *EC2_DescribeTransitGatewayRouteTables_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayVpcAttachments provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGatewayVpcAttachments(ctx context.Context, params *ec2.DescribeTransitGatewayVpcAttachmentsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGatewayVpcAttachments")
	}

	var r0 *ec2.DescribeTransitGatewayVpcAttachmentsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayVpcAttachmentsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewayVpcAttachmentsInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewayVpcAttachmentsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewayVpcAttachmentsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGatewayVpcAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGatewayVpcAttachments'
type EC2_DescribeTransitGatewayVpcAttachments_Call struct {
	*mock.Call
}

// DescribeTransitGatewayVpcAttachments is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewayVpcAttachmentsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGatewayVpcAttachments(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGatewayVpcAttachments_Call {
	return &EC2_DescribeTransitGatewayVpcAttachments_Call{Call: _e.mock.On("DescribeTransitGatewayVpcAttachments",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGatewayVpcAttachments_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewayVpcAttachmentsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGatewayVpcAttachments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewayVpcAttachmentsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGatewayVpcAttachments_Call) Return(_a0 *ec2.DescribeTransitGatewayVpcAttachmentsOutput, _a1 error) *EC2_DescribeTransitGatewayVpcAttachments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGatewayVpcAttachments_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewayVpcAttachmentsInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error)) *EC2_DescribeTransitGatewayVpcAttachments_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGateways provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTransitGateways(ctx context.Context, params *ec2.DescribeTransitGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTransitGatewaysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTransitGateways")
	}

	var r0 *ec2.DescribeTransitGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewaysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTransitGatewaysInput, ...func(*ec2.Options)) *ec2.DescribeTransitGatewaysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTransitGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTransitGatewaysInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTransitGateways_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTransitGateways'
type EC2_DescribeTransitGateways_Call struct {
	*mock.Call
}

// DescribeTransitGateways is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTransitGatewaysInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTransitGateways(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTransitGateways_Call {
	return &EC2_DescribeTransitGateways_Call{Call: _e.mock.On("DescribeTransitGateways",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTransitGateways_Call) Run(run func(ctx context.Context, params *ec2.DescribeTransitGatewaysInput, optFns ...func(*ec2.Options))) *EC2_DescribeTransitGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTransitGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTransitGateways_Call) Return(_a0 *ec2.DescribeTransitGatewaysOutput, _a1 error) *EC2_DescribeTransitGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTransitGateways_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTransitGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeTransitGatewaysOutput, error)) *EC2_DescribeTransitGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTrunkInterfaceAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeTrunkInterfaceAssociations(ctx context.Context, params *ec2.DescribeTrunkInterfaceAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTrunkInterfaceAssociations")
	}

	var r0 *ec2.DescribeTrunkInterfaceAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrunkInterfaceAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeTrunkInterfaceAssociationsInput, ...func(*ec2.Options)) *ec2.DescribeTrunkInterfaceAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeTrunkInterfaceAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeTrunkInterfaceAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeTrunkInterfaceAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTrunkInterfaceAssociations'
type EC2_DescribeTrunkInterfaceAssociations_Call struct {
	*mock.Call
}

// DescribeTrunkInterfaceAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeTrunkInterfaceAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeTrunkInterfaceAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeTrunkInterfaceAssociations_Call {
	return &EC2_DescribeTrunkInterfaceAssociations_Call{Call: _e.mock.On("DescribeTrunkInterfaceAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeTrunkInterfaceAssociations_Call) Run(run func(ctx context.Context, params *ec2.DescribeTrunkInterfaceAssociationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeTrunkInterfaceAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeTrunkInterfaceAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeTrunkInterfaceAssociations_Call) Return(_a0 *ec2.DescribeTrunkInterfaceAssociationsOutput, _a1 error) *EC2_DescribeTrunkInterfaceAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeTrunkInterfaceAssociations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeTrunkInterfaceAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error)) *EC2_DescribeTrunkInterfaceAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVerifiedAccessEndpoints provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVerifiedAccessEndpoints(ctx context.Context, params *ec2.DescribeVerifiedAccessEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessEndpointsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVerifiedAccessEndpoints")
	}

	var r0 *ec2.DescribeVerifiedAccessEndpointsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessEndpointsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessEndpointsInput, ...func(*ec2.Options)) *ec2.DescribeVerifiedAccessEndpointsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVerifiedAccessEndpointsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVerifiedAccessEndpointsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVerifiedAccessEndpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVerifiedAccessEndpoints'
type EC2_DescribeVerifiedAccessEndpoints_Call struct {
	*mock.Call
}

// DescribeVerifiedAccessEndpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVerifiedAccessEndpointsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVerifiedAccessEndpoints(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVerifiedAccessEndpoints_Call {
	return &EC2_DescribeVerifiedAccessEndpoints_Call{Call: _e.mock.On("DescribeVerifiedAccessEndpoints",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVerifiedAccessEndpoints_Call) Run(run func(ctx context.Context, params *ec2.DescribeVerifiedAccessEndpointsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVerifiedAccessEndpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVerifiedAccessEndpointsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVerifiedAccessEndpoints_Call) Return(_a0 *ec2.DescribeVerifiedAccessEndpointsOutput, _a1 error) *EC2_DescribeVerifiedAccessEndpoints_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVerifiedAccessEndpoints_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVerifiedAccessEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessEndpointsOutput, error)) *EC2_DescribeVerifiedAccessEndpoints_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVerifiedAccessGroups provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVerifiedAccessGroups(ctx context.Context, params *ec2.DescribeVerifiedAccessGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessGroupsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVerifiedAccessGroups")
	}

	var r0 *ec2.DescribeVerifiedAccessGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessGroupsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessGroupsInput, ...func(*ec2.Options)) *ec2.DescribeVerifiedAccessGroupsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVerifiedAccessGroupsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVerifiedAccessGroupsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVerifiedAccessGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVerifiedAccessGroups'
type EC2_DescribeVerifiedAccessGroups_Call struct {
	*mock.Call
}

// DescribeVerifiedAccessGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVerifiedAccessGroupsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVerifiedAccessGroups(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVerifiedAccessGroups_Call {
	return &EC2_DescribeVerifiedAccessGroups_Call{Call: _e.mock.On("DescribeVerifiedAccessGroups",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVerifiedAccessGroups_Call) Run(run func(ctx context.Context, params *ec2.DescribeVerifiedAccessGroupsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVerifiedAccessGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVerifiedAccessGroupsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVerifiedAccessGroups_Call) Return(_a0 *ec2.DescribeVerifiedAccessGroupsOutput, _a1 error) *EC2_DescribeVerifiedAccessGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVerifiedAccessGroups_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVerifiedAccessGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessGroupsOutput, error)) *EC2_DescribeVerifiedAccessGroups_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVerifiedAccessInstanceLoggingConfigurations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVerifiedAccessInstanceLoggingConfigurations(ctx context.Context, params *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVerifiedAccessInstanceLoggingConfigurations")
	}

	var r0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, ...func(*ec2.Options)) *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVerifiedAccessInstanceLoggingConfigurations'
type EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call struct {
	*mock.Call
}

// DescribeVerifiedAccessInstanceLoggingConfigurations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVerifiedAccessInstanceLoggingConfigurations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call {
	return &EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call{Call: _e.mock.On("DescribeVerifiedAccessInstanceLoggingConfigurations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call) Run(run func(ctx context.Context, params *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call) Return(_a0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, _a1 error) *EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error)) *EC2_DescribeVerifiedAccessInstanceLoggingConfigurations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVerifiedAccessInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVerifiedAccessInstances(ctx context.Context, params *ec2.DescribeVerifiedAccessInstancesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVerifiedAccessInstances")
	}

	var r0 *ec2.DescribeVerifiedAccessInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessInstancesInput, ...func(*ec2.Options)) *ec2.DescribeVerifiedAccessInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVerifiedAccessInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVerifiedAccessInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVerifiedAccessInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVerifiedAccessInstances'
type EC2_DescribeVerifiedAccessInstances_Call struct {
	*mock.Call
}

// DescribeVerifiedAccessInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVerifiedAccessInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVerifiedAccessInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVerifiedAccessInstances_Call {
	return &EC2_DescribeVerifiedAccessInstances_Call{Call: _e.mock.On("DescribeVerifiedAccessInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVerifiedAccessInstances_Call) Run(run func(ctx context.Context, params *ec2.DescribeVerifiedAccessInstancesInput, optFns ...func(*ec2.Options))) *EC2_DescribeVerifiedAccessInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVerifiedAccessInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVerifiedAccessInstances_Call) Return(_a0 *ec2.DescribeVerifiedAccessInstancesOutput, _a1 error) *EC2_DescribeVerifiedAccessInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVerifiedAccessInstances_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVerifiedAccessInstancesInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessInstancesOutput, error)) *EC2_DescribeVerifiedAccessInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVerifiedAccessTrustProviders provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVerifiedAccessTrustProviders(ctx context.Context, params *ec2.DescribeVerifiedAccessTrustProvidersInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVerifiedAccessTrustProviders")
	}

	var r0 *ec2.DescribeVerifiedAccessTrustProvidersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessTrustProvidersInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVerifiedAccessTrustProvidersInput, ...func(*ec2.Options)) *ec2.DescribeVerifiedAccessTrustProvidersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVerifiedAccessTrustProvidersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVerifiedAccessTrustProvidersInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVerifiedAccessTrustProviders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVerifiedAccessTrustProviders'
type EC2_DescribeVerifiedAccessTrustProviders_Call struct {
	*mock.Call
}

// DescribeVerifiedAccessTrustProviders is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVerifiedAccessTrustProvidersInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVerifiedAccessTrustProviders(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVerifiedAccessTrustProviders_Call {
	return &EC2_DescribeVerifiedAccessTrustProviders_Call{Call: _e.mock.On("DescribeVerifiedAccessTrustProviders",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVerifiedAccessTrustProviders_Call) Run(run func(ctx context.Context, params *ec2.DescribeVerifiedAccessTrustProvidersInput, optFns ...func(*ec2.Options))) *EC2_DescribeVerifiedAccessTrustProviders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVerifiedAccessTrustProvidersInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVerifiedAccessTrustProviders_Call) Return(_a0 *ec2.DescribeVerifiedAccessTrustProvidersOutput, _a1 error) *EC2_DescribeVerifiedAccessTrustProviders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVerifiedAccessTrustProviders_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVerifiedAccessTrustProvidersInput, ...func(*ec2.Options)) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error)) *EC2_DescribeVerifiedAccessTrustProviders_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVolumeAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVolumeAttribute(ctx context.Context, params *ec2.DescribeVolumeAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVolumeAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVolumeAttribute")
	}

	var r0 *ec2.DescribeVolumeAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumeAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeVolumeAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumeAttributeInput, ...func(*ec2.Options)) *ec2.DescribeVolumeAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumeAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVolumeAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVolumeAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVolumeAttribute'
type EC2_DescribeVolumeAttribute_Call struct {
	*mock.Call
}

// DescribeVolumeAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVolumeAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVolumeAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVolumeAttribute_Call {
	return &EC2_DescribeVolumeAttribute_Call{Call: _e.mock.On("DescribeVolumeAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVolumeAttribute_Call) Run(run func(ctx context.Context, params *ec2.DescribeVolumeAttributeInput, optFns ...func(*ec2.Options))) *EC2_DescribeVolumeAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVolumeAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVolumeAttribute_Call) Return(_a0 *ec2.DescribeVolumeAttributeOutput, _a1 error) *EC2_DescribeVolumeAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVolumeAttribute_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVolumeAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeVolumeAttributeOutput, error)) *EC2_DescribeVolumeAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVolumeStatus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVolumeStatus(ctx context.Context, params *ec2.DescribeVolumeStatusInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVolumeStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVolumeStatus")
	}

	var r0 *ec2.DescribeVolumeStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumeStatusInput, ...func(*ec2.Options)) (*ec2.DescribeVolumeStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumeStatusInput, ...func(*ec2.Options)) *ec2.DescribeVolumeStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumeStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVolumeStatusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVolumeStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVolumeStatus'
type EC2_DescribeVolumeStatus_Call struct {
	*mock.Call
}

// DescribeVolumeStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVolumeStatusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVolumeStatus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVolumeStatus_Call {
	return &EC2_DescribeVolumeStatus_Call{Call: _e.mock.On("DescribeVolumeStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVolumeStatus_Call) Run(run func(ctx context.Context, params *ec2.DescribeVolumeStatusInput, optFns ...func(*ec2.Options))) *EC2_DescribeVolumeStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVolumeStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVolumeStatus_Call) Return(_a0 *ec2.DescribeVolumeStatusOutput, _a1 error) *EC2_DescribeVolumeStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVolumeStatus_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVolumeStatusInput, ...func(*ec2.Options)) (*ec2.DescribeVolumeStatusOutput, error)) *EC2_DescribeVolumeStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVolumes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVolumes(ctx context.Context, params *ec2.DescribeVolumesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVolumesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVolumes")
	}

	var r0 *ec2.DescribeVolumesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumesInput, ...func(*ec2.Options)) (*ec2.DescribeVolumesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumesInput, ...func(*ec2.Options)) *ec2.DescribeVolumesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVolumesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVolumes'
type EC2_DescribeVolumes_Call struct {
	*mock.Call
}

// DescribeVolumes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVolumesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVolumes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVolumes_Call {
	return &EC2_DescribeVolumes_Call{Call: _e.mock.On("DescribeVolumes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVolumes_Call) Run(run func(ctx context.Context, params *ec2.DescribeVolumesInput, optFns ...func(*ec2.Options))) *EC2_DescribeVolumes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVolumesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVolumes_Call) Return(_a0 *ec2.DescribeVolumesOutput, _a1 error) *EC2_DescribeVolumes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVolumes_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVolumesInput, ...func(*ec2.Options)) (*ec2.DescribeVolumesOutput, error)) *EC2_DescribeVolumes_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVolumesModifications provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVolumesModifications(ctx context.Context, params *ec2.DescribeVolumesModificationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVolumesModificationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVolumesModifications")
	}

	var r0 *ec2.DescribeVolumesModificationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumesModificationsInput, ...func(*ec2.Options)) (*ec2.DescribeVolumesModificationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVolumesModificationsInput, ...func(*ec2.Options)) *ec2.DescribeVolumesModificationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVolumesModificationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVolumesModificationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVolumesModifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVolumesModifications'
type EC2_DescribeVolumesModifications_Call struct {
	*mock.Call
}

// DescribeVolumesModifications is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVolumesModificationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVolumesModifications(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVolumesModifications_Call {
	return &EC2_DescribeVolumesModifications_Call{Call: _e.mock.On("DescribeVolumesModifications",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVolumesModifications_Call) Run(run func(ctx context.Context, params *ec2.DescribeVolumesModificationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVolumesModifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVolumesModificationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVolumesModifications_Call) Return(_a0 *ec2.DescribeVolumesModificationsOutput, _a1 error) *EC2_DescribeVolumesModifications_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVolumesModifications_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVolumesModificationsInput, ...func(*ec2.Options)) (*ec2.DescribeVolumesModificationsOutput, error)) *EC2_DescribeVolumesModifications_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcAttribute(ctx context.Context, params *ec2.DescribeVpcAttributeInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcAttribute")
	}

	var r0 *ec2.DescribeVpcAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeVpcAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcAttributeInput, ...func(*ec2.Options)) *ec2.DescribeVpcAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcAttribute'
type EC2_DescribeVpcAttribute_Call struct {
	*mock.Call
}

// DescribeVpcAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcAttribute_Call {
	return &EC2_DescribeVpcAttribute_Call{Call: _e.mock.On("DescribeVpcAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcAttribute_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcAttributeInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcAttribute_Call) Return(_a0 *ec2.DescribeVpcAttributeOutput, _a1 error) *EC2_DescribeVpcAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcAttribute_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcAttributeInput, ...func(*ec2.Options)) (*ec2.DescribeVpcAttributeOutput, error)) *EC2_DescribeVpcAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcBlockPublicAccessExclusions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcBlockPublicAccessExclusions(ctx context.Context, params *ec2.DescribeVpcBlockPublicAccessExclusionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcBlockPublicAccessExclusionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcBlockPublicAccessExclusions")
	}

	var r0 *ec2.DescribeVpcBlockPublicAccessExclusionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcBlockPublicAccessExclusionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcBlockPublicAccessExclusionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcBlockPublicAccessExclusionsInput, ...func(*ec2.Options)) *ec2.DescribeVpcBlockPublicAccessExclusionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcBlockPublicAccessExclusionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcBlockPublicAccessExclusionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcBlockPublicAccessExclusions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcBlockPublicAccessExclusions'
type EC2_DescribeVpcBlockPublicAccessExclusions_Call struct {
	*mock.Call
}

// DescribeVpcBlockPublicAccessExclusions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcBlockPublicAccessExclusionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcBlockPublicAccessExclusions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcBlockPublicAccessExclusions_Call {
	return &EC2_DescribeVpcBlockPublicAccessExclusions_Call{Call: _e.mock.On("DescribeVpcBlockPublicAccessExclusions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcBlockPublicAccessExclusions_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcBlockPublicAccessExclusionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcBlockPublicAccessExclusions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcBlockPublicAccessExclusionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcBlockPublicAccessExclusions_Call) Return(_a0 *ec2.DescribeVpcBlockPublicAccessExclusionsOutput, _a1 error) *EC2_DescribeVpcBlockPublicAccessExclusions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcBlockPublicAccessExclusions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcBlockPublicAccessExclusionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcBlockPublicAccessExclusionsOutput, error)) *EC2_DescribeVpcBlockPublicAccessExclusions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcBlockPublicAccessOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcBlockPublicAccessOptions(ctx context.Context, params *ec2.DescribeVpcBlockPublicAccessOptionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcBlockPublicAccessOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcBlockPublicAccessOptions")
	}

	var r0 *ec2.DescribeVpcBlockPublicAccessOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcBlockPublicAccessOptionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcBlockPublicAccessOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcBlockPublicAccessOptionsInput, ...func(*ec2.Options)) *ec2.DescribeVpcBlockPublicAccessOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcBlockPublicAccessOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcBlockPublicAccessOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcBlockPublicAccessOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcBlockPublicAccessOptions'
type EC2_DescribeVpcBlockPublicAccessOptions_Call struct {
	*mock.Call
}

// DescribeVpcBlockPublicAccessOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcBlockPublicAccessOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcBlockPublicAccessOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcBlockPublicAccessOptions_Call {
	return &EC2_DescribeVpcBlockPublicAccessOptions_Call{Call: _e.mock.On("DescribeVpcBlockPublicAccessOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcBlockPublicAccessOptions_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcBlockPublicAccessOptionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcBlockPublicAccessOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcBlockPublicAccessOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcBlockPublicAccessOptions_Call) Return(_a0 *ec2.DescribeVpcBlockPublicAccessOptionsOutput, _a1 error) *EC2_DescribeVpcBlockPublicAccessOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcBlockPublicAccessOptions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcBlockPublicAccessOptionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcBlockPublicAccessOptionsOutput, error)) *EC2_DescribeVpcBlockPublicAccessOptions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcClassicLink provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcClassicLink(ctx context.Context, params *ec2.DescribeVpcClassicLinkInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcClassicLinkOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcClassicLink")
	}

	var r0 *ec2.DescribeVpcClassicLinkOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcClassicLinkInput, ...func(*ec2.Options)) (*ec2.DescribeVpcClassicLinkOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcClassicLinkInput, ...func(*ec2.Options)) *ec2.DescribeVpcClassicLinkOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcClassicLinkOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcClassicLinkInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcClassicLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcClassicLink'
type EC2_DescribeVpcClassicLink_Call struct {
	*mock.Call
}

// DescribeVpcClassicLink is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcClassicLinkInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcClassicLink(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcClassicLink_Call {
	return &EC2_DescribeVpcClassicLink_Call{Call: _e.mock.On("DescribeVpcClassicLink",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcClassicLink_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcClassicLinkInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcClassicLink_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcClassicLinkInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcClassicLink_Call) Return(_a0 *ec2.DescribeVpcClassicLinkOutput, _a1 error) *EC2_DescribeVpcClassicLink_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcClassicLink_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcClassicLinkInput, ...func(*ec2.Options)) (*ec2.DescribeVpcClassicLinkOutput, error)) *EC2_DescribeVpcClassicLink_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcClassicLinkDnsSupport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcClassicLinkDnsSupport(ctx context.Context, params *ec2.DescribeVpcClassicLinkDnsSupportInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcClassicLinkDnsSupport")
	}

	var r0 *ec2.DescribeVpcClassicLinkDnsSupportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) *ec2.DescribeVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcClassicLinkDnsSupport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcClassicLinkDnsSupport'
type EC2_DescribeVpcClassicLinkDnsSupport_Call struct {
	*mock.Call
}

// DescribeVpcClassicLinkDnsSupport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcClassicLinkDnsSupportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcClassicLinkDnsSupport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcClassicLinkDnsSupport_Call {
	return &EC2_DescribeVpcClassicLinkDnsSupport_Call{Call: _e.mock.On("DescribeVpcClassicLinkDnsSupport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcClassicLinkDnsSupport_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcClassicLinkDnsSupportInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcClassicLinkDnsSupport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcClassicLinkDnsSupportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcClassicLinkDnsSupport_Call) Return(_a0 *ec2.DescribeVpcClassicLinkDnsSupportOutput, _a1 error) *EC2_DescribeVpcClassicLinkDnsSupport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcClassicLinkDnsSupport_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error)) *EC2_DescribeVpcClassicLinkDnsSupport_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcEncryptionControls provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcEncryptionControls(ctx context.Context, params *ec2.DescribeVpcEncryptionControlsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEncryptionControlsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcEncryptionControls")
	}

	var r0 *ec2.DescribeVpcEncryptionControlsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEncryptionControlsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEncryptionControlsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEncryptionControlsInput, ...func(*ec2.Options)) *ec2.DescribeVpcEncryptionControlsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEncryptionControlsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEncryptionControlsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcEncryptionControls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEncryptionControls'
type EC2_DescribeVpcEncryptionControls_Call struct {
	*mock.Call
}

// DescribeVpcEncryptionControls is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcEncryptionControlsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcEncryptionControls(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEncryptionControls_Call {
	return &EC2_DescribeVpcEncryptionControls_Call{Call: _e.mock.On("DescribeVpcEncryptionControls",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcEncryptionControls_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEncryptionControlsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEncryptionControls_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEncryptionControlsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcEncryptionControls_Call) Return(_a0 *ec2.DescribeVpcEncryptionControlsOutput, _a1 error) *EC2_DescribeVpcEncryptionControls_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcEncryptionControls_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEncryptionControlsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEncryptionControlsOutput, error)) *EC2_DescribeVpcEncryptionControls_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcEndpointAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcEndpointAssociations(ctx context.Context, params *ec2.DescribeVpcEndpointAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcEndpointAssociations")
	}

	var r0 *ec2.DescribeVpcEndpointAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointAssociationsInput, ...func(*ec2.Options)) *ec2.DescribeVpcEndpointAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcEndpointAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEndpointAssociations'
type EC2_DescribeVpcEndpointAssociations_Call struct {
	*mock.Call
}

// DescribeVpcEndpointAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcEndpointAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcEndpointAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEndpointAssociations_Call {
	return &EC2_DescribeVpcEndpointAssociations_Call{Call: _e.mock.On("DescribeVpcEndpointAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcEndpointAssociations_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEndpointAssociationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEndpointAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEndpointAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcEndpointAssociations_Call) Return(_a0 *ec2.DescribeVpcEndpointAssociationsOutput, _a1 error) *EC2_DescribeVpcEndpointAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcEndpointAssociations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEndpointAssociationsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointAssociationsOutput, error)) *EC2_DescribeVpcEndpointAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcEndpointConnectionNotifications provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcEndpointConnectionNotifications(ctx context.Context, params *ec2.DescribeVpcEndpointConnectionNotificationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcEndpointConnectionNotifications")
	}

	var r0 *ec2.DescribeVpcEndpointConnectionNotificationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointConnectionNotificationsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointConnectionNotificationsInput, ...func(*ec2.Options)) *ec2.DescribeVpcEndpointConnectionNotificationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointConnectionNotificationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcEndpointConnectionNotifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEndpointConnectionNotifications'
type EC2_DescribeVpcEndpointConnectionNotifications_Call struct {
	*mock.Call
}

// DescribeVpcEndpointConnectionNotifications is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcEndpointConnectionNotificationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcEndpointConnectionNotifications(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEndpointConnectionNotifications_Call {
	return &EC2_DescribeVpcEndpointConnectionNotifications_Call{Call: _e.mock.On("DescribeVpcEndpointConnectionNotifications",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcEndpointConnectionNotifications_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEndpointConnectionNotificationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEndpointConnectionNotifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEndpointConnectionNotificationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcEndpointConnectionNotifications_Call) Return(_a0 *ec2.DescribeVpcEndpointConnectionNotificationsOutput, _a1 error) *EC2_DescribeVpcEndpointConnectionNotifications_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcEndpointConnectionNotifications_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEndpointConnectionNotificationsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error)) *EC2_DescribeVpcEndpointConnectionNotifications_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcEndpointConnections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcEndpointConnections(ctx context.Context, params *ec2.DescribeVpcEndpointConnectionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointConnectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcEndpointConnections")
	}

	var r0 *ec2.DescribeVpcEndpointConnectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointConnectionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointConnectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointConnectionsInput, ...func(*ec2.Options)) *ec2.DescribeVpcEndpointConnectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointConnectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointConnectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcEndpointConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEndpointConnections'
type EC2_DescribeVpcEndpointConnections_Call struct {
	*mock.Call
}

// DescribeVpcEndpointConnections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcEndpointConnectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcEndpointConnections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEndpointConnections_Call {
	return &EC2_DescribeVpcEndpointConnections_Call{Call: _e.mock.On("DescribeVpcEndpointConnections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcEndpointConnections_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEndpointConnectionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEndpointConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEndpointConnectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcEndpointConnections_Call) Return(_a0 *ec2.DescribeVpcEndpointConnectionsOutput, _a1 error) *EC2_DescribeVpcEndpointConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcEndpointConnections_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEndpointConnectionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointConnectionsOutput, error)) *EC2_DescribeVpcEndpointConnections_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcEndpointServiceConfigurations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcEndpointServiceConfigurations(ctx context.Context, params *ec2.DescribeVpcEndpointServiceConfigurationsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcEndpointServiceConfigurations")
	}

	var r0 *ec2.DescribeVpcEndpointServiceConfigurationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServiceConfigurationsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServiceConfigurationsInput, ...func(*ec2.Options)) *ec2.DescribeVpcEndpointServiceConfigurationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointServiceConfigurationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcEndpointServiceConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEndpointServiceConfigurations'
type EC2_DescribeVpcEndpointServiceConfigurations_Call struct {
	*mock.Call
}

// DescribeVpcEndpointServiceConfigurations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcEndpointServiceConfigurationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcEndpointServiceConfigurations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEndpointServiceConfigurations_Call {
	return &EC2_DescribeVpcEndpointServiceConfigurations_Call{Call: _e.mock.On("DescribeVpcEndpointServiceConfigurations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcEndpointServiceConfigurations_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEndpointServiceConfigurationsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEndpointServiceConfigurations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEndpointServiceConfigurationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcEndpointServiceConfigurations_Call) Return(_a0 *ec2.DescribeVpcEndpointServiceConfigurationsOutput, _a1 error) *EC2_DescribeVpcEndpointServiceConfigurations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcEndpointServiceConfigurations_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEndpointServiceConfigurationsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error)) *EC2_DescribeVpcEndpointServiceConfigurations_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcEndpointServicePermissions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcEndpointServicePermissions(ctx context.Context, params *ec2.DescribeVpcEndpointServicePermissionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcEndpointServicePermissions")
	}

	var r0 *ec2.DescribeVpcEndpointServicePermissionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServicePermissionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServicePermissionsInput, ...func(*ec2.Options)) *ec2.DescribeVpcEndpointServicePermissionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServicePermissionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointServicePermissionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcEndpointServicePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEndpointServicePermissions'
type EC2_DescribeVpcEndpointServicePermissions_Call struct {
	*mock.Call
}

// DescribeVpcEndpointServicePermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcEndpointServicePermissionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcEndpointServicePermissions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEndpointServicePermissions_Call {
	return &EC2_DescribeVpcEndpointServicePermissions_Call{Call: _e.mock.On("DescribeVpcEndpointServicePermissions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcEndpointServicePermissions_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEndpointServicePermissionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEndpointServicePermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEndpointServicePermissionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcEndpointServicePermissions_Call) Return(_a0 *ec2.DescribeVpcEndpointServicePermissionsOutput, _a1 error) *EC2_DescribeVpcEndpointServicePermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcEndpointServicePermissions_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEndpointServicePermissionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error)) *EC2_DescribeVpcEndpointServicePermissions_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcEndpointServices provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcEndpointServices(ctx context.Context, params *ec2.DescribeVpcEndpointServicesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServicesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcEndpointServices")
	}

	var r0 *ec2.DescribeVpcEndpointServicesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServicesInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServicesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointServicesInput, ...func(*ec2.Options)) *ec2.DescribeVpcEndpointServicesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointServicesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointServicesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcEndpointServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEndpointServices'
type EC2_DescribeVpcEndpointServices_Call struct {
	*mock.Call
}

// DescribeVpcEndpointServices is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcEndpointServicesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcEndpointServices(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEndpointServices_Call {
	return &EC2_DescribeVpcEndpointServices_Call{Call: _e.mock.On("DescribeVpcEndpointServices",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcEndpointServices_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEndpointServicesInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEndpointServices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEndpointServicesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcEndpointServices_Call) Return(_a0 *ec2.DescribeVpcEndpointServicesOutput, _a1 error) *EC2_DescribeVpcEndpointServices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcEndpointServices_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEndpointServicesInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointServicesOutput, error)) *EC2_DescribeVpcEndpointServices_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcEndpoints provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcEndpoints(ctx context.Context, params *ec2.DescribeVpcEndpointsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcEndpoints")
	}

	var r0 *ec2.DescribeVpcEndpointsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcEndpointsInput, ...func(*ec2.Options)) *ec2.DescribeVpcEndpointsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcEndpointsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcEndpointsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcEndpoints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcEndpoints'
type EC2_DescribeVpcEndpoints_Call struct {
	*mock.Call
}

// DescribeVpcEndpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcEndpointsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcEndpoints(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcEndpoints_Call {
	return &EC2_DescribeVpcEndpoints_Call{Call: _e.mock.On("DescribeVpcEndpoints",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcEndpoints_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcEndpointsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcEndpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcEndpointsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcEndpoints_Call) Return(_a0 *ec2.DescribeVpcEndpointsOutput, _a1 error) *EC2_DescribeVpcEndpoints_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcEndpoints_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcEndpointsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcEndpointsOutput, error)) *EC2_DescribeVpcEndpoints_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcPeeringConnections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcPeeringConnections(ctx context.Context, params *ec2.DescribeVpcPeeringConnectionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcPeeringConnectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcPeeringConnections")
	}

	var r0 *ec2.DescribeVpcPeeringConnectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcPeeringConnectionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcPeeringConnectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcPeeringConnectionsInput, ...func(*ec2.Options)) *ec2.DescribeVpcPeeringConnectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcPeeringConnectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcPeeringConnectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcPeeringConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcPeeringConnections'
type EC2_DescribeVpcPeeringConnections_Call struct {
	*mock.Call
}

// DescribeVpcPeeringConnections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcPeeringConnectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcPeeringConnections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcPeeringConnections_Call {
	return &EC2_DescribeVpcPeeringConnections_Call{Call: _e.mock.On("DescribeVpcPeeringConnections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcPeeringConnections_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcPeeringConnectionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcPeeringConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcPeeringConnectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcPeeringConnections_Call) Return(_a0 *ec2.DescribeVpcPeeringConnectionsOutput, _a1 error) *EC2_DescribeVpcPeeringConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcPeeringConnections_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcPeeringConnectionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcPeeringConnectionsOutput, error)) *EC2_DescribeVpcPeeringConnections_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpcs(ctx context.Context, params *ec2.DescribeVpcsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpcs")
	}

	var r0 *ec2.DescribeVpcsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpcsInput, ...func(*ec2.Options)) *ec2.DescribeVpcsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpcsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpcsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpcs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpcs'
type EC2_DescribeVpcs_Call struct {
	*mock.Call
}

// DescribeVpcs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpcsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpcs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpcs_Call {
	return &EC2_DescribeVpcs_Call{Call: _e.mock.On("DescribeVpcs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpcs_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpcs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpcsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpcs_Call) Return(_a0 *ec2.DescribeVpcsOutput, _a1 error) *EC2_DescribeVpcs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpcs_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error)) *EC2_DescribeVpcs_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpnConcentrators provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpnConcentrators(ctx context.Context, params *ec2.DescribeVpnConcentratorsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpnConcentratorsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpnConcentrators")
	}

	var r0 *ec2.DescribeVpnConcentratorsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnConcentratorsInput, ...func(*ec2.Options)) (*ec2.DescribeVpnConcentratorsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnConcentratorsInput, ...func(*ec2.Options)) *ec2.DescribeVpnConcentratorsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpnConcentratorsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpnConcentratorsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpnConcentrators_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpnConcentrators'
type EC2_DescribeVpnConcentrators_Call struct {
	*mock.Call
}

// DescribeVpnConcentrators is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpnConcentratorsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpnConcentrators(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpnConcentrators_Call {
	return &EC2_DescribeVpnConcentrators_Call{Call: _e.mock.On("DescribeVpnConcentrators",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpnConcentrators_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpnConcentratorsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpnConcentrators_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpnConcentratorsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpnConcentrators_Call) Return(_a0 *ec2.DescribeVpnConcentratorsOutput, _a1 error) *EC2_DescribeVpnConcentrators_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpnConcentrators_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpnConcentratorsInput, ...func(*ec2.Options)) (*ec2.DescribeVpnConcentratorsOutput, error)) *EC2_DescribeVpnConcentrators_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpnConnections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpnConnections(ctx context.Context, params *ec2.DescribeVpnConnectionsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpnConnectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpnConnections")
	}

	var r0 *ec2.DescribeVpnConnectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnConnectionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpnConnectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnConnectionsInput, ...func(*ec2.Options)) *ec2.DescribeVpnConnectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpnConnectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpnConnectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpnConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpnConnections'
type EC2_DescribeVpnConnections_Call struct {
	*mock.Call
}

// DescribeVpnConnections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpnConnectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpnConnections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpnConnections_Call {
	return &EC2_DescribeVpnConnections_Call{Call: _e.mock.On("DescribeVpnConnections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpnConnections_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpnConnectionsInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpnConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpnConnectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpnConnections_Call) Return(_a0 *ec2.DescribeVpnConnectionsOutput, _a1 error) *EC2_DescribeVpnConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpnConnections_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpnConnectionsInput, ...func(*ec2.Options)) (*ec2.DescribeVpnConnectionsOutput, error)) *EC2_DescribeVpnConnections_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpnGateways provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DescribeVpnGateways(ctx context.Context, params *ec2.DescribeVpnGatewaysInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpnGatewaysOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeVpnGateways")
	}

	var r0 *ec2.DescribeVpnGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeVpnGatewaysOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DescribeVpnGatewaysInput, ...func(*ec2.Options)) *ec2.DescribeVpnGatewaysOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DescribeVpnGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DescribeVpnGatewaysInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DescribeVpnGateways_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeVpnGateways'
type EC2_DescribeVpnGateways_Call struct {
	*mock.Call
}

// DescribeVpnGateways is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DescribeVpnGatewaysInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DescribeVpnGateways(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DescribeVpnGateways_Call {
	return &EC2_DescribeVpnGateways_Call{Call: _e.mock.On("DescribeVpnGateways",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DescribeVpnGateways_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpnGatewaysInput, optFns ...func(*ec2.Options))) *EC2_DescribeVpnGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DescribeVpnGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DescribeVpnGateways_Call) Return(_a0 *ec2.DescribeVpnGatewaysOutput, _a1 error) *EC2_DescribeVpnGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DescribeVpnGateways_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpnGatewaysInput, ...func(*ec2.Options)) (*ec2.DescribeVpnGatewaysOutput, error)) *EC2_DescribeVpnGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DetachClassicLinkVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DetachClassicLinkVpc(ctx context.Context, params *ec2.DetachClassicLinkVpcInput, optFns ...func(*ec2.Options)) (*ec2.DetachClassicLinkVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetachClassicLinkVpc")
	}

	var r0 *ec2.DetachClassicLinkVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachClassicLinkVpcInput, ...func(*ec2.Options)) (*ec2.DetachClassicLinkVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachClassicLinkVpcInput, ...func(*ec2.Options)) *ec2.DetachClassicLinkVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachClassicLinkVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachClassicLinkVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DetachClassicLinkVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetachClassicLinkVpc'
type EC2_DetachClassicLinkVpc_Call struct {
	*mock.Call
}

// DetachClassicLinkVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DetachClassicLinkVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DetachClassicLinkVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DetachClassicLinkVpc_Call {
	return &EC2_DetachClassicLinkVpc_Call{Call: _e.mock.On("DetachClassicLinkVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DetachClassicLinkVpc_Call) Run(run func(ctx context.Context, params *ec2.DetachClassicLinkVpcInput, optFns ...func(*ec2.Options))) *EC2_DetachClassicLinkVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DetachClassicLinkVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DetachClassicLinkVpc_Call) Return(_a0 *ec2.DetachClassicLinkVpcOutput, _a1 error) *EC2_DetachClassicLinkVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DetachClassicLinkVpc_Call) RunAndReturn(run func(context.Context, *ec2.DetachClassicLinkVpcInput, ...func(*ec2.Options)) (*ec2.DetachClassicLinkVpcOutput, error)) *EC2_DetachClassicLinkVpc_Call {
	_c.Call.Return(run)
	return _c
}

// DetachInternetGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DetachInternetGateway(ctx context.Context, params *ec2.DetachInternetGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DetachInternetGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetachInternetGateway")
	}

	var r0 *ec2.DetachInternetGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachInternetGatewayInput, ...func(*ec2.Options)) (*ec2.DetachInternetGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachInternetGatewayInput, ...func(*ec2.Options)) *ec2.DetachInternetGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachInternetGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachInternetGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DetachInternetGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetachInternetGateway'
type EC2_DetachInternetGateway_Call struct {
	*mock.Call
}

// DetachInternetGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DetachInternetGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DetachInternetGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DetachInternetGateway_Call {
	return &EC2_DetachInternetGateway_Call{Call: _e.mock.On("DetachInternetGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DetachInternetGateway_Call) Run(run func(ctx context.Context, params *ec2.DetachInternetGatewayInput, optFns ...func(*ec2.Options))) *EC2_DetachInternetGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DetachInternetGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DetachInternetGateway_Call) Return(_a0 *ec2.DetachInternetGatewayOutput, _a1 error) *EC2_DetachInternetGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DetachInternetGateway_Call) RunAndReturn(run func(context.Context, *ec2.DetachInternetGatewayInput, ...func(*ec2.Options)) (*ec2.DetachInternetGatewayOutput, error)) *EC2_DetachInternetGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DetachNetworkInterface provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DetachNetworkInterface(ctx context.Context, params *ec2.DetachNetworkInterfaceInput, optFns ...func(*ec2.Options)) (*ec2.DetachNetworkInterfaceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetachNetworkInterface")
	}

	var r0 *ec2.DetachNetworkInterfaceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachNetworkInterfaceInput, ...func(*ec2.Options)) (*ec2.DetachNetworkInterfaceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachNetworkInterfaceInput, ...func(*ec2.Options)) *ec2.DetachNetworkInterfaceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachNetworkInterfaceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachNetworkInterfaceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DetachNetworkInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetachNetworkInterface'
type EC2_DetachNetworkInterface_Call struct {
	*mock.Call
}

// DetachNetworkInterface is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DetachNetworkInterfaceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DetachNetworkInterface(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DetachNetworkInterface_Call {
	return &EC2_DetachNetworkInterface_Call{Call: _e.mock.On("DetachNetworkInterface",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DetachNetworkInterface_Call) Run(run func(ctx context.Context, params *ec2.DetachNetworkInterfaceInput, optFns ...func(*ec2.Options))) *EC2_DetachNetworkInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DetachNetworkInterfaceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DetachNetworkInterface_Call) Return(_a0 *ec2.DetachNetworkInterfaceOutput, _a1 error) *EC2_DetachNetworkInterface_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DetachNetworkInterface_Call) RunAndReturn(run func(context.Context, *ec2.DetachNetworkInterfaceInput, ...func(*ec2.Options)) (*ec2.DetachNetworkInterfaceOutput, error)) *EC2_DetachNetworkInterface_Call {
	_c.Call.Return(run)
	return _c
}

// DetachVerifiedAccessTrustProvider provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DetachVerifiedAccessTrustProvider(ctx context.Context, params *ec2.DetachVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options)) (*ec2.DetachVerifiedAccessTrustProviderOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetachVerifiedAccessTrustProvider")
	}

	var r0 *ec2.DetachVerifiedAccessTrustProviderOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.DetachVerifiedAccessTrustProviderOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) *ec2.DetachVerifiedAccessTrustProviderOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachVerifiedAccessTrustProviderOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DetachVerifiedAccessTrustProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetachVerifiedAccessTrustProvider'
type EC2_DetachVerifiedAccessTrustProvider_Call struct {
	*mock.Call
}

// DetachVerifiedAccessTrustProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DetachVerifiedAccessTrustProviderInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DetachVerifiedAccessTrustProvider(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DetachVerifiedAccessTrustProvider_Call {
	return &EC2_DetachVerifiedAccessTrustProvider_Call{Call: _e.mock.On("DetachVerifiedAccessTrustProvider",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DetachVerifiedAccessTrustProvider_Call) Run(run func(ctx context.Context, params *ec2.DetachVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options))) *EC2_DetachVerifiedAccessTrustProvider_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DetachVerifiedAccessTrustProviderInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DetachVerifiedAccessTrustProvider_Call) Return(_a0 *ec2.DetachVerifiedAccessTrustProviderOutput, _a1 error) *EC2_DetachVerifiedAccessTrustProvider_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DetachVerifiedAccessTrustProvider_Call) RunAndReturn(run func(context.Context, *ec2.DetachVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.DetachVerifiedAccessTrustProviderOutput, error)) *EC2_DetachVerifiedAccessTrustProvider_Call {
	_c.Call.Return(run)
	return _c
}

// DetachVolume provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DetachVolume(ctx context.Context, params *ec2.DetachVolumeInput, optFns ...func(*ec2.Options)) (*ec2.DetachVolumeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetachVolume")
	}

	var r0 *ec2.DetachVolumeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachVolumeInput, ...func(*ec2.Options)) (*ec2.DetachVolumeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachVolumeInput, ...func(*ec2.Options)) *ec2.DetachVolumeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachVolumeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachVolumeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DetachVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetachVolume'
type EC2_DetachVolume_Call struct {
	*mock.Call
}

// DetachVolume is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DetachVolumeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DetachVolume(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DetachVolume_Call {
	return &EC2_DetachVolume_Call{Call: _e.mock.On("DetachVolume",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DetachVolume_Call) Run(run func(ctx context.Context, params *ec2.DetachVolumeInput, optFns ...func(*ec2.Options))) *EC2_DetachVolume_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DetachVolumeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DetachVolume_Call) Return(_a0 *ec2.DetachVolumeOutput, _a1 error) *EC2_DetachVolume_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DetachVolume_Call) RunAndReturn(run func(context.Context, *ec2.DetachVolumeInput, ...func(*ec2.Options)) (*ec2.DetachVolumeOutput, error)) *EC2_DetachVolume_Call {
	_c.Call.Return(run)
	return _c
}

// DetachVpnGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DetachVpnGateway(ctx context.Context, params *ec2.DetachVpnGatewayInput, optFns ...func(*ec2.Options)) (*ec2.DetachVpnGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetachVpnGateway")
	}

	var r0 *ec2.DetachVpnGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachVpnGatewayInput, ...func(*ec2.Options)) (*ec2.DetachVpnGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DetachVpnGatewayInput, ...func(*ec2.Options)) *ec2.DetachVpnGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DetachVpnGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DetachVpnGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DetachVpnGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetachVpnGateway'
type EC2_DetachVpnGateway_Call struct {
	*mock.Call
}

// DetachVpnGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DetachVpnGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DetachVpnGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DetachVpnGateway_Call {
	return &EC2_DetachVpnGateway_Call{Call: _e.mock.On("DetachVpnGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DetachVpnGateway_Call) Run(run func(ctx context.Context, params *ec2.DetachVpnGatewayInput, optFns ...func(*ec2.Options))) *EC2_DetachVpnGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DetachVpnGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DetachVpnGateway_Call) Return(_a0 *ec2.DetachVpnGatewayOutput, _a1 error) *EC2_DetachVpnGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DetachVpnGateway_Call) RunAndReturn(run func(context.Context, *ec2.DetachVpnGatewayInput, ...func(*ec2.Options)) (*ec2.DetachVpnGatewayOutput, error)) *EC2_DetachVpnGateway_Call {
	_c.Call.Return(run)
	return _c
}

// DisableAddressTransfer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableAddressTransfer(ctx context.Context, params *ec2.DisableAddressTransferInput, optFns ...func(*ec2.Options)) (*ec2.DisableAddressTransferOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableAddressTransfer")
	}

	var r0 *ec2.DisableAddressTransferOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableAddressTransferInput, ...func(*ec2.Options)) (*ec2.DisableAddressTransferOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableAddressTransferInput, ...func(*ec2.Options)) *ec2.DisableAddressTransferOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableAddressTransferOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableAddressTransferInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableAddressTransfer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableAddressTransfer'
type EC2_DisableAddressTransfer_Call struct {
	*mock.Call
}

// DisableAddressTransfer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableAddressTransferInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableAddressTransfer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableAddressTransfer_Call {
	return &EC2_DisableAddressTransfer_Call{Call: _e.mock.On("DisableAddressTransfer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableAddressTransfer_Call) Run(run func(ctx context.Context, params *ec2.DisableAddressTransferInput, optFns ...func(*ec2.Options))) *EC2_DisableAddressTransfer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableAddressTransferInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableAddressTransfer_Call) Return(_a0 *ec2.DisableAddressTransferOutput, _a1 error) *EC2_DisableAddressTransfer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableAddressTransfer_Call) RunAndReturn(run func(context.Context, *ec2.DisableAddressTransferInput, ...func(*ec2.Options)) (*ec2.DisableAddressTransferOutput, error)) *EC2_DisableAddressTransfer_Call {
	_c.Call.Return(run)
	return _c
}

// DisableAllowedImagesSettings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableAllowedImagesSettings(ctx context.Context, params *ec2.DisableAllowedImagesSettingsInput, optFns ...func(*ec2.Options)) (*ec2.DisableAllowedImagesSettingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableAllowedImagesSettings")
	}

	var r0 *ec2.DisableAllowedImagesSettingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableAllowedImagesSettingsInput, ...func(*ec2.Options)) (*ec2.DisableAllowedImagesSettingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableAllowedImagesSettingsInput, ...func(*ec2.Options)) *ec2.DisableAllowedImagesSettingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableAllowedImagesSettingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableAllowedImagesSettingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableAllowedImagesSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableAllowedImagesSettings'
type EC2_DisableAllowedImagesSettings_Call struct {
	*mock.Call
}

// DisableAllowedImagesSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableAllowedImagesSettingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableAllowedImagesSettings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableAllowedImagesSettings_Call {
	return &EC2_DisableAllowedImagesSettings_Call{Call: _e.mock.On("DisableAllowedImagesSettings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableAllowedImagesSettings_Call) Run(run func(ctx context.Context, params *ec2.DisableAllowedImagesSettingsInput, optFns ...func(*ec2.Options))) *EC2_DisableAllowedImagesSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableAllowedImagesSettingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableAllowedImagesSettings_Call) Return(_a0 *ec2.DisableAllowedImagesSettingsOutput, _a1 error) *EC2_DisableAllowedImagesSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableAllowedImagesSettings_Call) RunAndReturn(run func(context.Context, *ec2.DisableAllowedImagesSettingsInput, ...func(*ec2.Options)) (*ec2.DisableAllowedImagesSettingsOutput, error)) *EC2_DisableAllowedImagesSettings_Call {
	_c.Call.Return(run)
	return _c
}

// DisableAwsNetworkPerformanceMetricSubscription provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableAwsNetworkPerformanceMetricSubscription(ctx context.Context, params *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, optFns ...func(*ec2.Options)) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableAwsNetworkPerformanceMetricSubscription")
	}

	var r0 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, ...func(*ec2.Options)) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, ...func(*ec2.Options)) *ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableAwsNetworkPerformanceMetricSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableAwsNetworkPerformanceMetricSubscription'
type EC2_DisableAwsNetworkPerformanceMetricSubscription_Call struct {
	*mock.Call
}

// DisableAwsNetworkPerformanceMetricSubscription is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableAwsNetworkPerformanceMetricSubscription(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableAwsNetworkPerformanceMetricSubscription_Call {
	return &EC2_DisableAwsNetworkPerformanceMetricSubscription_Call{Call: _e.mock.On("DisableAwsNetworkPerformanceMetricSubscription",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableAwsNetworkPerformanceMetricSubscription_Call) Run(run func(ctx context.Context, params *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, optFns ...func(*ec2.Options))) *EC2_DisableAwsNetworkPerformanceMetricSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableAwsNetworkPerformanceMetricSubscription_Call) Return(_a0 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, _a1 error) *EC2_DisableAwsNetworkPerformanceMetricSubscription_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableAwsNetworkPerformanceMetricSubscription_Call) RunAndReturn(run func(context.Context, *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, ...func(*ec2.Options)) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error)) *EC2_DisableAwsNetworkPerformanceMetricSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// DisableCapacityManager provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableCapacityManager(ctx context.Context, params *ec2.DisableCapacityManagerInput, optFns ...func(*ec2.Options)) (*ec2.DisableCapacityManagerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableCapacityManager")
	}

	var r0 *ec2.DisableCapacityManagerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableCapacityManagerInput, ...func(*ec2.Options)) (*ec2.DisableCapacityManagerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableCapacityManagerInput, ...func(*ec2.Options)) *ec2.DisableCapacityManagerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableCapacityManagerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableCapacityManagerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableCapacityManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableCapacityManager'
type EC2_DisableCapacityManager_Call struct {
	*mock.Call
}

// DisableCapacityManager is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableCapacityManagerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableCapacityManager(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableCapacityManager_Call {
	return &EC2_DisableCapacityManager_Call{Call: _e.mock.On("DisableCapacityManager",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableCapacityManager_Call) Run(run func(ctx context.Context, params *ec2.DisableCapacityManagerInput, optFns ...func(*ec2.Options))) *EC2_DisableCapacityManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableCapacityManagerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableCapacityManager_Call) Return(_a0 *ec2.DisableCapacityManagerOutput, _a1 error) *EC2_DisableCapacityManager_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableCapacityManager_Call) RunAndReturn(run func(context.Context, *ec2.DisableCapacityManagerInput, ...func(*ec2.Options)) (*ec2.DisableCapacityManagerOutput, error)) *EC2_DisableCapacityManager_Call {
	_c.Call.Return(run)
	return _c
}

// DisableEbsEncryptionByDefault provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableEbsEncryptionByDefault(ctx context.Context, params *ec2.DisableEbsEncryptionByDefaultInput, optFns ...func(*ec2.Options)) (*ec2.DisableEbsEncryptionByDefaultOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableEbsEncryptionByDefault")
	}

	var r0 *ec2.DisableEbsEncryptionByDefaultOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableEbsEncryptionByDefaultInput, ...func(*ec2.Options)) (*ec2.DisableEbsEncryptionByDefaultOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableEbsEncryptionByDefaultInput, ...func(*ec2.Options)) *ec2.DisableEbsEncryptionByDefaultOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableEbsEncryptionByDefaultOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableEbsEncryptionByDefaultInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableEbsEncryptionByDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableEbsEncryptionByDefault'
type EC2_DisableEbsEncryptionByDefault_Call struct {
	*mock.Call
}

// DisableEbsEncryptionByDefault is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableEbsEncryptionByDefaultInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableEbsEncryptionByDefault(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableEbsEncryptionByDefault_Call {
	return &EC2_DisableEbsEncryptionByDefault_Call{Call: _e.mock.On("DisableEbsEncryptionByDefault",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableEbsEncryptionByDefault_Call) Run(run func(ctx context.Context, params *ec2.DisableEbsEncryptionByDefaultInput, optFns ...func(*ec2.Options))) *EC2_DisableEbsEncryptionByDefault_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableEbsEncryptionByDefaultInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableEbsEncryptionByDefault_Call) Return(_a0 *ec2.DisableEbsEncryptionByDefaultOutput, _a1 error) *EC2_DisableEbsEncryptionByDefault_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableEbsEncryptionByDefault_Call) RunAndReturn(run func(context.Context, *ec2.DisableEbsEncryptionByDefaultInput, ...func(*ec2.Options)) (*ec2.DisableEbsEncryptionByDefaultOutput, error)) *EC2_DisableEbsEncryptionByDefault_Call {
	_c.Call.Return(run)
	return _c
}

// DisableFastLaunch provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableFastLaunch(ctx context.Context, params *ec2.DisableFastLaunchInput, optFns ...func(*ec2.Options)) (*ec2.DisableFastLaunchOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableFastLaunch")
	}

	var r0 *ec2.DisableFastLaunchOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableFastLaunchInput, ...func(*ec2.Options)) (*ec2.DisableFastLaunchOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableFastLaunchInput, ...func(*ec2.Options)) *ec2.DisableFastLaunchOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableFastLaunchOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableFastLaunchInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableFastLaunch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableFastLaunch'
type EC2_DisableFastLaunch_Call struct {
	*mock.Call
}

// DisableFastLaunch is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableFastLaunchInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableFastLaunch(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableFastLaunch_Call {
	return &EC2_DisableFastLaunch_Call{Call: _e.mock.On("DisableFastLaunch",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableFastLaunch_Call) Run(run func(ctx context.Context, params *ec2.DisableFastLaunchInput, optFns ...func(*ec2.Options))) *EC2_DisableFastLaunch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableFastLaunchInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableFastLaunch_Call) Return(_a0 *ec2.DisableFastLaunchOutput, _a1 error) *EC2_DisableFastLaunch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableFastLaunch_Call) RunAndReturn(run func(context.Context, *ec2.DisableFastLaunchInput, ...func(*ec2.Options)) (*ec2.DisableFastLaunchOutput, error)) *EC2_DisableFastLaunch_Call {
	_c.Call.Return(run)
	return _c
}

// DisableFastSnapshotRestores provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableFastSnapshotRestores(ctx context.Context, params *ec2.DisableFastSnapshotRestoresInput, optFns ...func(*ec2.Options)) (*ec2.DisableFastSnapshotRestoresOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableFastSnapshotRestores")
	}

	var r0 *ec2.DisableFastSnapshotRestoresOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableFastSnapshotRestoresInput, ...func(*ec2.Options)) (*ec2.DisableFastSnapshotRestoresOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableFastSnapshotRestoresInput, ...func(*ec2.Options)) *ec2.DisableFastSnapshotRestoresOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableFastSnapshotRestoresOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableFastSnapshotRestoresInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableFastSnapshotRestores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableFastSnapshotRestores'
type EC2_DisableFastSnapshotRestores_Call struct {
	*mock.Call
}

// DisableFastSnapshotRestores is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableFastSnapshotRestoresInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableFastSnapshotRestores(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableFastSnapshotRestores_Call {
	return &EC2_DisableFastSnapshotRestores_Call{Call: _e.mock.On("DisableFastSnapshotRestores",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableFastSnapshotRestores_Call) Run(run func(ctx context.Context, params *ec2.DisableFastSnapshotRestoresInput, optFns ...func(*ec2.Options))) *EC2_DisableFastSnapshotRestores_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableFastSnapshotRestoresInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableFastSnapshotRestores_Call) Return(_a0 *ec2.DisableFastSnapshotRestoresOutput, _a1 error) *EC2_DisableFastSnapshotRestores_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableFastSnapshotRestores_Call) RunAndReturn(run func(context.Context, *ec2.DisableFastSnapshotRestoresInput, ...func(*ec2.Options)) (*ec2.DisableFastSnapshotRestoresOutput, error)) *EC2_DisableFastSnapshotRestores_Call {
	_c.Call.Return(run)
	return _c
}

// DisableImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableImage(ctx context.Context, params *ec2.DisableImageInput, optFns ...func(*ec2.Options)) (*ec2.DisableImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableImage")
	}

	var r0 *ec2.DisableImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageInput, ...func(*ec2.Options)) (*ec2.DisableImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageInput, ...func(*ec2.Options)) *ec2.DisableImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableImage'
type EC2_DisableImage_Call struct {
	*mock.Call
}

// DisableImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableImage_Call {
	return &EC2_DisableImage_Call{Call: _e.mock.On("DisableImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableImage_Call) Run(run func(ctx context.Context, params *ec2.DisableImageInput, optFns ...func(*ec2.Options))) *EC2_DisableImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableImage_Call) Return(_a0 *ec2.DisableImageOutput, _a1 error) *EC2_DisableImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableImage_Call) RunAndReturn(run func(context.Context, *ec2.DisableImageInput, ...func(*ec2.Options)) (*ec2.DisableImageOutput, error)) *EC2_DisableImage_Call {
	_c.Call.Return(run)
	return _c
}

// DisableImageBlockPublicAccess provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableImageBlockPublicAccess(ctx context.Context, params *ec2.DisableImageBlockPublicAccessInput, optFns ...func(*ec2.Options)) (*ec2.DisableImageBlockPublicAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableImageBlockPublicAccess")
	}

	var r0 *ec2.DisableImageBlockPublicAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageBlockPublicAccessInput, ...func(*ec2.Options)) (*ec2.DisableImageBlockPublicAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageBlockPublicAccessInput, ...func(*ec2.Options)) *ec2.DisableImageBlockPublicAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableImageBlockPublicAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableImageBlockPublicAccessInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableImageBlockPublicAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableImageBlockPublicAccess'
type EC2_DisableImageBlockPublicAccess_Call struct {
	*mock.Call
}

// DisableImageBlockPublicAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableImageBlockPublicAccessInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableImageBlockPublicAccess(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableImageBlockPublicAccess_Call {
	return &EC2_DisableImageBlockPublicAccess_Call{Call: _e.mock.On("DisableImageBlockPublicAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableImageBlockPublicAccess_Call) Run(run func(ctx context.Context, params *ec2.DisableImageBlockPublicAccessInput, optFns ...func(*ec2.Options))) *EC2_DisableImageBlockPublicAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableImageBlockPublicAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableImageBlockPublicAccess_Call) Return(_a0 *ec2.DisableImageBlockPublicAccessOutput, _a1 error) *EC2_DisableImageBlockPublicAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableImageBlockPublicAccess_Call) RunAndReturn(run func(context.Context, *ec2.DisableImageBlockPublicAccessInput, ...func(*ec2.Options)) (*ec2.DisableImageBlockPublicAccessOutput, error)) *EC2_DisableImageBlockPublicAccess_Call {
	_c.Call.Return(run)
	return _c
}

// DisableImageDeprecation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableImageDeprecation(ctx context.Context, params *ec2.DisableImageDeprecationInput, optFns ...func(*ec2.Options)) (*ec2.DisableImageDeprecationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableImageDeprecation")
	}

	var r0 *ec2.DisableImageDeprecationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageDeprecationInput, ...func(*ec2.Options)) (*ec2.DisableImageDeprecationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageDeprecationInput, ...func(*ec2.Options)) *ec2.DisableImageDeprecationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableImageDeprecationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableImageDeprecationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableImageDeprecation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableImageDeprecation'
type EC2_DisableImageDeprecation_Call struct {
	*mock.Call
}

// DisableImageDeprecation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableImageDeprecationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableImageDeprecation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableImageDeprecation_Call {
	return &EC2_DisableImageDeprecation_Call{Call: _e.mock.On("DisableImageDeprecation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableImageDeprecation_Call) Run(run func(ctx context.Context, params *ec2.DisableImageDeprecationInput, optFns ...func(*ec2.Options))) *EC2_DisableImageDeprecation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableImageDeprecationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableImageDeprecation_Call) Return(_a0 *ec2.DisableImageDeprecationOutput, _a1 error) *EC2_DisableImageDeprecation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableImageDeprecation_Call) RunAndReturn(run func(context.Context, *ec2.DisableImageDeprecationInput, ...func(*ec2.Options)) (*ec2.DisableImageDeprecationOutput, error)) *EC2_DisableImageDeprecation_Call {
	_c.Call.Return(run)
	return _c
}

// DisableImageDeregistrationProtection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableImageDeregistrationProtection(ctx context.Context, params *ec2.DisableImageDeregistrationProtectionInput, optFns ...func(*ec2.Options)) (*ec2.DisableImageDeregistrationProtectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableImageDeregistrationProtection")
	}

	var r0 *ec2.DisableImageDeregistrationProtectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageDeregistrationProtectionInput, ...func(*ec2.Options)) (*ec2.DisableImageDeregistrationProtectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableImageDeregistrationProtectionInput, ...func(*ec2.Options)) *ec2.DisableImageDeregistrationProtectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableImageDeregistrationProtectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableImageDeregistrationProtectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableImageDeregistrationProtection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableImageDeregistrationProtection'
type EC2_DisableImageDeregistrationProtection_Call struct {
	*mock.Call
}

// DisableImageDeregistrationProtection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableImageDeregistrationProtectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableImageDeregistrationProtection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableImageDeregistrationProtection_Call {
	return &EC2_DisableImageDeregistrationProtection_Call{Call: _e.mock.On("DisableImageDeregistrationProtection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableImageDeregistrationProtection_Call) Run(run func(ctx context.Context, params *ec2.DisableImageDeregistrationProtectionInput, optFns ...func(*ec2.Options))) *EC2_DisableImageDeregistrationProtection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableImageDeregistrationProtectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableImageDeregistrationProtection_Call) Return(_a0 *ec2.DisableImageDeregistrationProtectionOutput, _a1 error) *EC2_DisableImageDeregistrationProtection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableImageDeregistrationProtection_Call) RunAndReturn(run func(context.Context, *ec2.DisableImageDeregistrationProtectionInput, ...func(*ec2.Options)) (*ec2.DisableImageDeregistrationProtectionOutput, error)) *EC2_DisableImageDeregistrationProtection_Call {
	_c.Call.Return(run)
	return _c
}

// DisableInstanceSqlHaStandbyDetections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableInstanceSqlHaStandbyDetections(ctx context.Context, params *ec2.DisableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*ec2.Options)) (*ec2.DisableInstanceSqlHaStandbyDetectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableInstanceSqlHaStandbyDetections")
	}

	var r0 *ec2.DisableInstanceSqlHaStandbyDetectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) (*ec2.DisableInstanceSqlHaStandbyDetectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) *ec2.DisableInstanceSqlHaStandbyDetectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableInstanceSqlHaStandbyDetectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableInstanceSqlHaStandbyDetections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableInstanceSqlHaStandbyDetections'
type EC2_DisableInstanceSqlHaStandbyDetections_Call struct {
	*mock.Call
}

// DisableInstanceSqlHaStandbyDetections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableInstanceSqlHaStandbyDetectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableInstanceSqlHaStandbyDetections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableInstanceSqlHaStandbyDetections_Call {
	return &EC2_DisableInstanceSqlHaStandbyDetections_Call{Call: _e.mock.On("DisableInstanceSqlHaStandbyDetections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableInstanceSqlHaStandbyDetections_Call) Run(run func(ctx context.Context, params *ec2.DisableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*ec2.Options))) *EC2_DisableInstanceSqlHaStandbyDetections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableInstanceSqlHaStandbyDetectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableInstanceSqlHaStandbyDetections_Call) Return(_a0 *ec2.DisableInstanceSqlHaStandbyDetectionsOutput, _a1 error) *EC2_DisableInstanceSqlHaStandbyDetections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableInstanceSqlHaStandbyDetections_Call) RunAndReturn(run func(context.Context, *ec2.DisableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) (*ec2.DisableInstanceSqlHaStandbyDetectionsOutput, error)) *EC2_DisableInstanceSqlHaStandbyDetections_Call {
	_c.Call.Return(run)
	return _c
}

// DisableIpamOrganizationAdminAccount provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableIpamOrganizationAdminAccount(ctx context.Context, params *ec2.DisableIpamOrganizationAdminAccountInput, optFns ...func(*ec2.Options)) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableIpamOrganizationAdminAccount")
	}

	var r0 *ec2.DisableIpamOrganizationAdminAccountOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableIpamOrganizationAdminAccountInput, ...func(*ec2.Options)) (*ec2.DisableIpamOrganizationAdminAccountOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableIpamOrganizationAdminAccountInput, ...func(*ec2.Options)) *ec2.DisableIpamOrganizationAdminAccountOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableIpamOrganizationAdminAccountOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableIpamOrganizationAdminAccountInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableIpamOrganizationAdminAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableIpamOrganizationAdminAccount'
type EC2_DisableIpamOrganizationAdminAccount_Call struct {
	*mock.Call
}

// DisableIpamOrganizationAdminAccount is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableIpamOrganizationAdminAccountInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableIpamOrganizationAdminAccount(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableIpamOrganizationAdminAccount_Call {
	return &EC2_DisableIpamOrganizationAdminAccount_Call{Call: _e.mock.On("DisableIpamOrganizationAdminAccount",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableIpamOrganizationAdminAccount_Call) Run(run func(ctx context.Context, params *ec2.DisableIpamOrganizationAdminAccountInput, optFns ...func(*ec2.Options))) *EC2_DisableIpamOrganizationAdminAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableIpamOrganizationAdminAccountInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableIpamOrganizationAdminAccount_Call) Return(_a0 *ec2.DisableIpamOrganizationAdminAccountOutput, _a1 error) *EC2_DisableIpamOrganizationAdminAccount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableIpamOrganizationAdminAccount_Call) RunAndReturn(run func(context.Context, *ec2.DisableIpamOrganizationAdminAccountInput, ...func(*ec2.Options)) (*ec2.DisableIpamOrganizationAdminAccountOutput, error)) *EC2_DisableIpamOrganizationAdminAccount_Call {
	_c.Call.Return(run)
	return _c
}

// DisableIpamPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableIpamPolicy(ctx context.Context, params *ec2.DisableIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.DisableIpamPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableIpamPolicy")
	}

	var r0 *ec2.DisableIpamPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableIpamPolicyInput, ...func(*ec2.Options)) (*ec2.DisableIpamPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableIpamPolicyInput, ...func(*ec2.Options)) *ec2.DisableIpamPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableIpamPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableIpamPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableIpamPolicy'
type EC2_DisableIpamPolicy_Call struct {
	*mock.Call
}

// DisableIpamPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableIpamPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableIpamPolicy_Call {
	return &EC2_DisableIpamPolicy_Call{Call: _e.mock.On("DisableIpamPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.DisableIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_DisableIpamPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableIpamPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableIpamPolicy_Call) Return(_a0 *ec2.DisableIpamPolicyOutput, _a1 error) *EC2_DisableIpamPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.DisableIpamPolicyInput, ...func(*ec2.Options)) (*ec2.DisableIpamPolicyOutput, error)) *EC2_DisableIpamPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// DisableRouteServerPropagation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableRouteServerPropagation(ctx context.Context, params *ec2.DisableRouteServerPropagationInput, optFns ...func(*ec2.Options)) (*ec2.DisableRouteServerPropagationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableRouteServerPropagation")
	}

	var r0 *ec2.DisableRouteServerPropagationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableRouteServerPropagationInput, ...func(*ec2.Options)) (*ec2.DisableRouteServerPropagationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableRouteServerPropagationInput, ...func(*ec2.Options)) *ec2.DisableRouteServerPropagationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableRouteServerPropagationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableRouteServerPropagationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableRouteServerPropagation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableRouteServerPropagation'
type EC2_DisableRouteServerPropagation_Call struct {
	*mock.Call
}

// DisableRouteServerPropagation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableRouteServerPropagationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableRouteServerPropagation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableRouteServerPropagation_Call {
	return &EC2_DisableRouteServerPropagation_Call{Call: _e.mock.On("DisableRouteServerPropagation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableRouteServerPropagation_Call) Run(run func(ctx context.Context, params *ec2.DisableRouteServerPropagationInput, optFns ...func(*ec2.Options))) *EC2_DisableRouteServerPropagation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableRouteServerPropagationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableRouteServerPropagation_Call) Return(_a0 *ec2.DisableRouteServerPropagationOutput, _a1 error) *EC2_DisableRouteServerPropagation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableRouteServerPropagation_Call) RunAndReturn(run func(context.Context, *ec2.DisableRouteServerPropagationInput, ...func(*ec2.Options)) (*ec2.DisableRouteServerPropagationOutput, error)) *EC2_DisableRouteServerPropagation_Call {
	_c.Call.Return(run)
	return _c
}

// DisableSerialConsoleAccess provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableSerialConsoleAccess(ctx context.Context, params *ec2.DisableSerialConsoleAccessInput, optFns ...func(*ec2.Options)) (*ec2.DisableSerialConsoleAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableSerialConsoleAccess")
	}

	var r0 *ec2.DisableSerialConsoleAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableSerialConsoleAccessInput, ...func(*ec2.Options)) (*ec2.DisableSerialConsoleAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableSerialConsoleAccessInput, ...func(*ec2.Options)) *ec2.DisableSerialConsoleAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableSerialConsoleAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableSerialConsoleAccessInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableSerialConsoleAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableSerialConsoleAccess'
type EC2_DisableSerialConsoleAccess_Call struct {
	*mock.Call
}

// DisableSerialConsoleAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableSerialConsoleAccessInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableSerialConsoleAccess(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableSerialConsoleAccess_Call {
	return &EC2_DisableSerialConsoleAccess_Call{Call: _e.mock.On("DisableSerialConsoleAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableSerialConsoleAccess_Call) Run(run func(ctx context.Context, params *ec2.DisableSerialConsoleAccessInput, optFns ...func(*ec2.Options))) *EC2_DisableSerialConsoleAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableSerialConsoleAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableSerialConsoleAccess_Call) Return(_a0 *ec2.DisableSerialConsoleAccessOutput, _a1 error) *EC2_DisableSerialConsoleAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableSerialConsoleAccess_Call) RunAndReturn(run func(context.Context, *ec2.DisableSerialConsoleAccessInput, ...func(*ec2.Options)) (*ec2.DisableSerialConsoleAccessOutput, error)) *EC2_DisableSerialConsoleAccess_Call {
	_c.Call.Return(run)
	return _c
}

// DisableSnapshotBlockPublicAccess provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableSnapshotBlockPublicAccess(ctx context.Context, params *ec2.DisableSnapshotBlockPublicAccessInput, optFns ...func(*ec2.Options)) (*ec2.DisableSnapshotBlockPublicAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableSnapshotBlockPublicAccess")
	}

	var r0 *ec2.DisableSnapshotBlockPublicAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableSnapshotBlockPublicAccessInput, ...func(*ec2.Options)) (*ec2.DisableSnapshotBlockPublicAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableSnapshotBlockPublicAccessInput, ...func(*ec2.Options)) *ec2.DisableSnapshotBlockPublicAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableSnapshotBlockPublicAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableSnapshotBlockPublicAccessInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableSnapshotBlockPublicAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableSnapshotBlockPublicAccess'
type EC2_DisableSnapshotBlockPublicAccess_Call struct {
	*mock.Call
}

// DisableSnapshotBlockPublicAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableSnapshotBlockPublicAccessInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableSnapshotBlockPublicAccess(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableSnapshotBlockPublicAccess_Call {
	return &EC2_DisableSnapshotBlockPublicAccess_Call{Call: _e.mock.On("DisableSnapshotBlockPublicAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableSnapshotBlockPublicAccess_Call) Run(run func(ctx context.Context, params *ec2.DisableSnapshotBlockPublicAccessInput, optFns ...func(*ec2.Options))) *EC2_DisableSnapshotBlockPublicAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableSnapshotBlockPublicAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableSnapshotBlockPublicAccess_Call) Return(_a0 *ec2.DisableSnapshotBlockPublicAccessOutput, _a1 error) *EC2_DisableSnapshotBlockPublicAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableSnapshotBlockPublicAccess_Call) RunAndReturn(run func(context.Context, *ec2.DisableSnapshotBlockPublicAccessInput, ...func(*ec2.Options)) (*ec2.DisableSnapshotBlockPublicAccessOutput, error)) *EC2_DisableSnapshotBlockPublicAccess_Call {
	_c.Call.Return(run)
	return _c
}

// DisableTransitGatewayRouteTablePropagation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableTransitGatewayRouteTablePropagation(ctx context.Context, params *ec2.DisableTransitGatewayRouteTablePropagationInput, optFns ...func(*ec2.Options)) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableTransitGatewayRouteTablePropagation")
	}

	var r0 *ec2.DisableTransitGatewayRouteTablePropagationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableTransitGatewayRouteTablePropagationInput, ...func(*ec2.Options)) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableTransitGatewayRouteTablePropagationInput, ...func(*ec2.Options)) *ec2.DisableTransitGatewayRouteTablePropagationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableTransitGatewayRouteTablePropagationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableTransitGatewayRouteTablePropagation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableTransitGatewayRouteTablePropagation'
type EC2_DisableTransitGatewayRouteTablePropagation_Call struct {
	*mock.Call
}

// DisableTransitGatewayRouteTablePropagation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableTransitGatewayRouteTablePropagationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableTransitGatewayRouteTablePropagation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableTransitGatewayRouteTablePropagation_Call {
	return &EC2_DisableTransitGatewayRouteTablePropagation_Call{Call: _e.mock.On("DisableTransitGatewayRouteTablePropagation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableTransitGatewayRouteTablePropagation_Call) Run(run func(ctx context.Context, params *ec2.DisableTransitGatewayRouteTablePropagationInput, optFns ...func(*ec2.Options))) *EC2_DisableTransitGatewayRouteTablePropagation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableTransitGatewayRouteTablePropagationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableTransitGatewayRouteTablePropagation_Call) Return(_a0 *ec2.DisableTransitGatewayRouteTablePropagationOutput, _a1 error) *EC2_DisableTransitGatewayRouteTablePropagation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableTransitGatewayRouteTablePropagation_Call) RunAndReturn(run func(context.Context, *ec2.DisableTransitGatewayRouteTablePropagationInput, ...func(*ec2.Options)) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error)) *EC2_DisableTransitGatewayRouteTablePropagation_Call {
	_c.Call.Return(run)
	return _c
}

// DisableVgwRoutePropagation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableVgwRoutePropagation(ctx context.Context, params *ec2.DisableVgwRoutePropagationInput, optFns ...func(*ec2.Options)) (*ec2.DisableVgwRoutePropagationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableVgwRoutePropagation")
	}

	var r0 *ec2.DisableVgwRoutePropagationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVgwRoutePropagationInput, ...func(*ec2.Options)) (*ec2.DisableVgwRoutePropagationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVgwRoutePropagationInput, ...func(*ec2.Options)) *ec2.DisableVgwRoutePropagationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVgwRoutePropagationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableVgwRoutePropagationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableVgwRoutePropagation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableVgwRoutePropagation'
type EC2_DisableVgwRoutePropagation_Call struct {
	*mock.Call
}

// DisableVgwRoutePropagation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableVgwRoutePropagationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableVgwRoutePropagation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableVgwRoutePropagation_Call {
	return &EC2_DisableVgwRoutePropagation_Call{Call: _e.mock.On("DisableVgwRoutePropagation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableVgwRoutePropagation_Call) Run(run func(ctx context.Context, params *ec2.DisableVgwRoutePropagationInput, optFns ...func(*ec2.Options))) *EC2_DisableVgwRoutePropagation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableVgwRoutePropagationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableVgwRoutePropagation_Call) Return(_a0 *ec2.DisableVgwRoutePropagationOutput, _a1 error) *EC2_DisableVgwRoutePropagation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableVgwRoutePropagation_Call) RunAndReturn(run func(context.Context, *ec2.DisableVgwRoutePropagationInput, ...func(*ec2.Options)) (*ec2.DisableVgwRoutePropagationOutput, error)) *EC2_DisableVgwRoutePropagation_Call {
	_c.Call.Return(run)
	return _c
}

// DisableVpcClassicLink provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableVpcClassicLink(ctx context.Context, params *ec2.DisableVpcClassicLinkInput, optFns ...func(*ec2.Options)) (*ec2.DisableVpcClassicLinkOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableVpcClassicLink")
	}

	var r0 *ec2.DisableVpcClassicLinkOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVpcClassicLinkInput, ...func(*ec2.Options)) (*ec2.DisableVpcClassicLinkOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVpcClassicLinkInput, ...func(*ec2.Options)) *ec2.DisableVpcClassicLinkOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVpcClassicLinkOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableVpcClassicLinkInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableVpcClassicLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableVpcClassicLink'
type EC2_DisableVpcClassicLink_Call struct {
	*mock.Call
}

// DisableVpcClassicLink is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableVpcClassicLinkInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableVpcClassicLink(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableVpcClassicLink_Call {
	return &EC2_DisableVpcClassicLink_Call{Call: _e.mock.On("DisableVpcClassicLink",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableVpcClassicLink_Call) Run(run func(ctx context.Context, params *ec2.DisableVpcClassicLinkInput, optFns ...func(*ec2.Options))) *EC2_DisableVpcClassicLink_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableVpcClassicLinkInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableVpcClassicLink_Call) Return(_a0 *ec2.DisableVpcClassicLinkOutput, _a1 error) *EC2_DisableVpcClassicLink_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableVpcClassicLink_Call) RunAndReturn(run func(context.Context, *ec2.DisableVpcClassicLinkInput, ...func(*ec2.Options)) (*ec2.DisableVpcClassicLinkOutput, error)) *EC2_DisableVpcClassicLink_Call {
	_c.Call.Return(run)
	return _c
}

// DisableVpcClassicLinkDnsSupport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisableVpcClassicLinkDnsSupport(ctx context.Context, params *ec2.DisableVpcClassicLinkDnsSupportInput, optFns ...func(*ec2.Options)) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisableVpcClassicLinkDnsSupport")
	}

	var r0 *ec2.DisableVpcClassicLinkDnsSupportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisableVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) *ec2.DisableVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisableVpcClassicLinkDnsSupportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisableVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisableVpcClassicLinkDnsSupport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableVpcClassicLinkDnsSupport'
type EC2_DisableVpcClassicLinkDnsSupport_Call struct {
	*mock.Call
}

// DisableVpcClassicLinkDnsSupport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisableVpcClassicLinkDnsSupportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisableVpcClassicLinkDnsSupport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisableVpcClassicLinkDnsSupport_Call {
	return &EC2_DisableVpcClassicLinkDnsSupport_Call{Call: _e.mock.On("DisableVpcClassicLinkDnsSupport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisableVpcClassicLinkDnsSupport_Call) Run(run func(ctx context.Context, params *ec2.DisableVpcClassicLinkDnsSupportInput, optFns ...func(*ec2.Options))) *EC2_DisableVpcClassicLinkDnsSupport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisableVpcClassicLinkDnsSupportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisableVpcClassicLinkDnsSupport_Call) Return(_a0 *ec2.DisableVpcClassicLinkDnsSupportOutput, _a1 error) *EC2_DisableVpcClassicLinkDnsSupport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisableVpcClassicLinkDnsSupport_Call) RunAndReturn(run func(context.Context, *ec2.DisableVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error)) *EC2_DisableVpcClassicLinkDnsSupport_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateAddress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateAddress(ctx context.Context, params *ec2.DisassociateAddressInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateAddressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateAddress")
	}

	var r0 *ec2.DisassociateAddressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateAddressInput, ...func(*ec2.Options)) (*ec2.DisassociateAddressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateAddressInput, ...func(*ec2.Options)) *ec2.DisassociateAddressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateAddressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateAddressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateAddress'
type EC2_DisassociateAddress_Call struct {
	*mock.Call
}

// DisassociateAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateAddressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateAddress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateAddress_Call {
	return &EC2_DisassociateAddress_Call{Call: _e.mock.On("DisassociateAddress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateAddress_Call) Run(run func(ctx context.Context, params *ec2.DisassociateAddressInput, optFns ...func(*ec2.Options))) *EC2_DisassociateAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateAddressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateAddress_Call) Return(_a0 *ec2.DisassociateAddressOutput, _a1 error) *EC2_DisassociateAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateAddress_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateAddressInput, ...func(*ec2.Options)) (*ec2.DisassociateAddressOutput, error)) *EC2_DisassociateAddress_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateCapacityReservationBillingOwner provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateCapacityReservationBillingOwner(ctx context.Context, params *ec2.DisassociateCapacityReservationBillingOwnerInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateCapacityReservationBillingOwnerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateCapacityReservationBillingOwner")
	}

	var r0 *ec2.DisassociateCapacityReservationBillingOwnerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateCapacityReservationBillingOwnerInput, ...func(*ec2.Options)) (*ec2.DisassociateCapacityReservationBillingOwnerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateCapacityReservationBillingOwnerInput, ...func(*ec2.Options)) *ec2.DisassociateCapacityReservationBillingOwnerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateCapacityReservationBillingOwnerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateCapacityReservationBillingOwnerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateCapacityReservationBillingOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateCapacityReservationBillingOwner'
type EC2_DisassociateCapacityReservationBillingOwner_Call struct {
	*mock.Call
}

// DisassociateCapacityReservationBillingOwner is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateCapacityReservationBillingOwnerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateCapacityReservationBillingOwner(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateCapacityReservationBillingOwner_Call {
	return &EC2_DisassociateCapacityReservationBillingOwner_Call{Call: _e.mock.On("DisassociateCapacityReservationBillingOwner",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateCapacityReservationBillingOwner_Call) Run(run func(ctx context.Context, params *ec2.DisassociateCapacityReservationBillingOwnerInput, optFns ...func(*ec2.Options))) *EC2_DisassociateCapacityReservationBillingOwner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateCapacityReservationBillingOwnerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateCapacityReservationBillingOwner_Call) Return(_a0 *ec2.DisassociateCapacityReservationBillingOwnerOutput, _a1 error) *EC2_DisassociateCapacityReservationBillingOwner_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateCapacityReservationBillingOwner_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateCapacityReservationBillingOwnerInput, ...func(*ec2.Options)) (*ec2.DisassociateCapacityReservationBillingOwnerOutput, error)) *EC2_DisassociateCapacityReservationBillingOwner_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateClientVpnTargetNetwork provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateClientVpnTargetNetwork(ctx context.Context, params *ec2.DisassociateClientVpnTargetNetworkInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateClientVpnTargetNetwork")
	}

	var r0 *ec2.DisassociateClientVpnTargetNetworkOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateClientVpnTargetNetworkInput, ...func(*ec2.Options)) (*ec2.DisassociateClientVpnTargetNetworkOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateClientVpnTargetNetworkInput, ...func(*ec2.Options)) *ec2.DisassociateClientVpnTargetNetworkOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateClientVpnTargetNetworkOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateClientVpnTargetNetworkInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateClientVpnTargetNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateClientVpnTargetNetwork'
type EC2_DisassociateClientVpnTargetNetwork_Call struct {
	*mock.Call
}

// DisassociateClientVpnTargetNetwork is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateClientVpnTargetNetworkInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateClientVpnTargetNetwork(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateClientVpnTargetNetwork_Call {
	return &EC2_DisassociateClientVpnTargetNetwork_Call{Call: _e.mock.On("DisassociateClientVpnTargetNetwork",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateClientVpnTargetNetwork_Call) Run(run func(ctx context.Context, params *ec2.DisassociateClientVpnTargetNetworkInput, optFns ...func(*ec2.Options))) *EC2_DisassociateClientVpnTargetNetwork_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateClientVpnTargetNetworkInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateClientVpnTargetNetwork_Call) Return(_a0 *ec2.DisassociateClientVpnTargetNetworkOutput, _a1 error) *EC2_DisassociateClientVpnTargetNetwork_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateClientVpnTargetNetwork_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateClientVpnTargetNetworkInput, ...func(*ec2.Options)) (*ec2.DisassociateClientVpnTargetNetworkOutput, error)) *EC2_DisassociateClientVpnTargetNetwork_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateEnclaveCertificateIamRole provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateEnclaveCertificateIamRole(ctx context.Context, params *ec2.DisassociateEnclaveCertificateIamRoleInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateEnclaveCertificateIamRole")
	}

	var r0 *ec2.DisassociateEnclaveCertificateIamRoleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateEnclaveCertificateIamRoleInput, ...func(*ec2.Options)) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateEnclaveCertificateIamRoleInput, ...func(*ec2.Options)) *ec2.DisassociateEnclaveCertificateIamRoleOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateEnclaveCertificateIamRoleInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateEnclaveCertificateIamRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateEnclaveCertificateIamRole'
type EC2_DisassociateEnclaveCertificateIamRole_Call struct {
	*mock.Call
}

// DisassociateEnclaveCertificateIamRole is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateEnclaveCertificateIamRoleInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateEnclaveCertificateIamRole(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateEnclaveCertificateIamRole_Call {
	return &EC2_DisassociateEnclaveCertificateIamRole_Call{Call: _e.mock.On("DisassociateEnclaveCertificateIamRole",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateEnclaveCertificateIamRole_Call) Run(run func(ctx context.Context, params *ec2.DisassociateEnclaveCertificateIamRoleInput, optFns ...func(*ec2.Options))) *EC2_DisassociateEnclaveCertificateIamRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateEnclaveCertificateIamRoleInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateEnclaveCertificateIamRole_Call) Return(_a0 *ec2.DisassociateEnclaveCertificateIamRoleOutput, _a1 error) *EC2_DisassociateEnclaveCertificateIamRole_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateEnclaveCertificateIamRole_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateEnclaveCertificateIamRoleInput, ...func(*ec2.Options)) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error)) *EC2_DisassociateEnclaveCertificateIamRole_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateIamInstanceProfile provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateIamInstanceProfile(ctx context.Context, params *ec2.DisassociateIamInstanceProfileInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateIamInstanceProfileOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateIamInstanceProfile")
	}

	var r0 *ec2.DisassociateIamInstanceProfileOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateIamInstanceProfileInput, ...func(*ec2.Options)) (*ec2.DisassociateIamInstanceProfileOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateIamInstanceProfileInput, ...func(*ec2.Options)) *ec2.DisassociateIamInstanceProfileOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateIamInstanceProfileOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateIamInstanceProfileInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateIamInstanceProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateIamInstanceProfile'
type EC2_DisassociateIamInstanceProfile_Call struct {
	*mock.Call
}

// DisassociateIamInstanceProfile is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateIamInstanceProfileInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateIamInstanceProfile(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateIamInstanceProfile_Call {
	return &EC2_DisassociateIamInstanceProfile_Call{Call: _e.mock.On("DisassociateIamInstanceProfile",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateIamInstanceProfile_Call) Run(run func(ctx context.Context, params *ec2.DisassociateIamInstanceProfileInput, optFns ...func(*ec2.Options))) *EC2_DisassociateIamInstanceProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateIamInstanceProfileInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateIamInstanceProfile_Call) Return(_a0 *ec2.DisassociateIamInstanceProfileOutput, _a1 error) *EC2_DisassociateIamInstanceProfile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateIamInstanceProfile_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateIamInstanceProfileInput, ...func(*ec2.Options)) (*ec2.DisassociateIamInstanceProfileOutput, error)) *EC2_DisassociateIamInstanceProfile_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateInstanceEventWindow provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateInstanceEventWindow(ctx context.Context, params *ec2.DisassociateInstanceEventWindowInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateInstanceEventWindowOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateInstanceEventWindow")
	}

	var r0 *ec2.DisassociateInstanceEventWindowOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.DisassociateInstanceEventWindowOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateInstanceEventWindowInput, ...func(*ec2.Options)) *ec2.DisassociateInstanceEventWindowOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateInstanceEventWindowOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateInstanceEventWindowInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateInstanceEventWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateInstanceEventWindow'
type EC2_DisassociateInstanceEventWindow_Call struct {
	*mock.Call
}

// DisassociateInstanceEventWindow is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateInstanceEventWindowInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateInstanceEventWindow(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateInstanceEventWindow_Call {
	return &EC2_DisassociateInstanceEventWindow_Call{Call: _e.mock.On("DisassociateInstanceEventWindow",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateInstanceEventWindow_Call) Run(run func(ctx context.Context, params *ec2.DisassociateInstanceEventWindowInput, optFns ...func(*ec2.Options))) *EC2_DisassociateInstanceEventWindow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateInstanceEventWindowInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateInstanceEventWindow_Call) Return(_a0 *ec2.DisassociateInstanceEventWindowOutput, _a1 error) *EC2_DisassociateInstanceEventWindow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateInstanceEventWindow_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.DisassociateInstanceEventWindowOutput, error)) *EC2_DisassociateInstanceEventWindow_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateIpamByoasn provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateIpamByoasn(ctx context.Context, params *ec2.DisassociateIpamByoasnInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateIpamByoasnOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateIpamByoasn")
	}

	var r0 *ec2.DisassociateIpamByoasnOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateIpamByoasnInput, ...func(*ec2.Options)) (*ec2.DisassociateIpamByoasnOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateIpamByoasnInput, ...func(*ec2.Options)) *ec2.DisassociateIpamByoasnOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateIpamByoasnOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateIpamByoasnInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateIpamByoasn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateIpamByoasn'
type EC2_DisassociateIpamByoasn_Call struct {
	*mock.Call
}

// DisassociateIpamByoasn is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateIpamByoasnInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateIpamByoasn(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateIpamByoasn_Call {
	return &EC2_DisassociateIpamByoasn_Call{Call: _e.mock.On("DisassociateIpamByoasn",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateIpamByoasn_Call) Run(run func(ctx context.Context, params *ec2.DisassociateIpamByoasnInput, optFns ...func(*ec2.Options))) *EC2_DisassociateIpamByoasn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateIpamByoasnInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateIpamByoasn_Call) Return(_a0 *ec2.DisassociateIpamByoasnOutput, _a1 error) *EC2_DisassociateIpamByoasn_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateIpamByoasn_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateIpamByoasnInput, ...func(*ec2.Options)) (*ec2.DisassociateIpamByoasnOutput, error)) *EC2_DisassociateIpamByoasn_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateIpamResourceDiscovery provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateIpamResourceDiscovery(ctx context.Context, params *ec2.DisassociateIpamResourceDiscoveryInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateIpamResourceDiscoveryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateIpamResourceDiscovery")
	}

	var r0 *ec2.DisassociateIpamResourceDiscoveryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.DisassociateIpamResourceDiscoveryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateIpamResourceDiscoveryInput, ...func(*ec2.Options)) *ec2.DisassociateIpamResourceDiscoveryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateIpamResourceDiscoveryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateIpamResourceDiscoveryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateIpamResourceDiscovery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateIpamResourceDiscovery'
type EC2_DisassociateIpamResourceDiscovery_Call struct {
	*mock.Call
}

// DisassociateIpamResourceDiscovery is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateIpamResourceDiscoveryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateIpamResourceDiscovery(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateIpamResourceDiscovery_Call {
	return &EC2_DisassociateIpamResourceDiscovery_Call{Call: _e.mock.On("DisassociateIpamResourceDiscovery",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateIpamResourceDiscovery_Call) Run(run func(ctx context.Context, params *ec2.DisassociateIpamResourceDiscoveryInput, optFns ...func(*ec2.Options))) *EC2_DisassociateIpamResourceDiscovery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateIpamResourceDiscoveryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateIpamResourceDiscovery_Call) Return(_a0 *ec2.DisassociateIpamResourceDiscoveryOutput, _a1 error) *EC2_DisassociateIpamResourceDiscovery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateIpamResourceDiscovery_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.DisassociateIpamResourceDiscoveryOutput, error)) *EC2_DisassociateIpamResourceDiscovery_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateNatGatewayAddress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateNatGatewayAddress(ctx context.Context, params *ec2.DisassociateNatGatewayAddressInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateNatGatewayAddressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateNatGatewayAddress")
	}

	var r0 *ec2.DisassociateNatGatewayAddressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateNatGatewayAddressInput, ...func(*ec2.Options)) (*ec2.DisassociateNatGatewayAddressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateNatGatewayAddressInput, ...func(*ec2.Options)) *ec2.DisassociateNatGatewayAddressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateNatGatewayAddressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateNatGatewayAddressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateNatGatewayAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateNatGatewayAddress'
type EC2_DisassociateNatGatewayAddress_Call struct {
	*mock.Call
}

// DisassociateNatGatewayAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateNatGatewayAddressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateNatGatewayAddress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateNatGatewayAddress_Call {
	return &EC2_DisassociateNatGatewayAddress_Call{Call: _e.mock.On("DisassociateNatGatewayAddress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateNatGatewayAddress_Call) Run(run func(ctx context.Context, params *ec2.DisassociateNatGatewayAddressInput, optFns ...func(*ec2.Options))) *EC2_DisassociateNatGatewayAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateNatGatewayAddressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateNatGatewayAddress_Call) Return(_a0 *ec2.DisassociateNatGatewayAddressOutput, _a1 error) *EC2_DisassociateNatGatewayAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateNatGatewayAddress_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateNatGatewayAddressInput, ...func(*ec2.Options)) (*ec2.DisassociateNatGatewayAddressOutput, error)) *EC2_DisassociateNatGatewayAddress_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateRouteServer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateRouteServer(ctx context.Context, params *ec2.DisassociateRouteServerInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateRouteServerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateRouteServer")
	}

	var r0 *ec2.DisassociateRouteServerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateRouteServerInput, ...func(*ec2.Options)) (*ec2.DisassociateRouteServerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateRouteServerInput, ...func(*ec2.Options)) *ec2.DisassociateRouteServerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateRouteServerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateRouteServerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateRouteServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateRouteServer'
type EC2_DisassociateRouteServer_Call struct {
	*mock.Call
}

// DisassociateRouteServer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateRouteServerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateRouteServer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateRouteServer_Call {
	return &EC2_DisassociateRouteServer_Call{Call: _e.mock.On("DisassociateRouteServer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateRouteServer_Call) Run(run func(ctx context.Context, params *ec2.DisassociateRouteServerInput, optFns ...func(*ec2.Options))) *EC2_DisassociateRouteServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateRouteServerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateRouteServer_Call) Return(_a0 *ec2.DisassociateRouteServerOutput, _a1 error) *EC2_DisassociateRouteServer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateRouteServer_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateRouteServerInput, ...func(*ec2.Options)) (*ec2.DisassociateRouteServerOutput, error)) *EC2_DisassociateRouteServer_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateRouteTable(ctx context.Context, params *ec2.DisassociateRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateRouteTable")
	}

	var r0 *ec2.DisassociateRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateRouteTableInput, ...func(*ec2.Options)) (*ec2.DisassociateRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateRouteTableInput, ...func(*ec2.Options)) *ec2.DisassociateRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateRouteTable'
type EC2_DisassociateRouteTable_Call struct {
	*mock.Call
}

// DisassociateRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateRouteTable_Call {
	return &EC2_DisassociateRouteTable_Call{Call: _e.mock.On("DisassociateRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateRouteTable_Call) Run(run func(ctx context.Context, params *ec2.DisassociateRouteTableInput, optFns ...func(*ec2.Options))) *EC2_DisassociateRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateRouteTable_Call) Return(_a0 *ec2.DisassociateRouteTableOutput, _a1 error) *EC2_DisassociateRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateRouteTableInput, ...func(*ec2.Options)) (*ec2.DisassociateRouteTableOutput, error)) *EC2_DisassociateRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateSecurityGroupVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateSecurityGroupVpc(ctx context.Context, params *ec2.DisassociateSecurityGroupVpcInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateSecurityGroupVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateSecurityGroupVpc")
	}

	var r0 *ec2.DisassociateSecurityGroupVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateSecurityGroupVpcInput, ...func(*ec2.Options)) (*ec2.DisassociateSecurityGroupVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateSecurityGroupVpcInput, ...func(*ec2.Options)) *ec2.DisassociateSecurityGroupVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateSecurityGroupVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateSecurityGroupVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateSecurityGroupVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateSecurityGroupVpc'
type EC2_DisassociateSecurityGroupVpc_Call struct {
	*mock.Call
}

// DisassociateSecurityGroupVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateSecurityGroupVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateSecurityGroupVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateSecurityGroupVpc_Call {
	return &EC2_DisassociateSecurityGroupVpc_Call{Call: _e.mock.On("DisassociateSecurityGroupVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateSecurityGroupVpc_Call) Run(run func(ctx context.Context, params *ec2.DisassociateSecurityGroupVpcInput, optFns ...func(*ec2.Options))) *EC2_DisassociateSecurityGroupVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateSecurityGroupVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateSecurityGroupVpc_Call) Return(_a0 *ec2.DisassociateSecurityGroupVpcOutput, _a1 error) *EC2_DisassociateSecurityGroupVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateSecurityGroupVpc_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateSecurityGroupVpcInput, ...func(*ec2.Options)) (*ec2.DisassociateSecurityGroupVpcOutput, error)) *EC2_DisassociateSecurityGroupVpc_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateSubnetCidrBlock provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateSubnetCidrBlock(ctx context.Context, params *ec2.DisassociateSubnetCidrBlockInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateSubnetCidrBlockOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateSubnetCidrBlock")
	}

	var r0 *ec2.DisassociateSubnetCidrBlockOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateSubnetCidrBlockInput, ...func(*ec2.Options)) (*ec2.DisassociateSubnetCidrBlockOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateSubnetCidrBlockInput, ...func(*ec2.Options)) *ec2.DisassociateSubnetCidrBlockOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateSubnetCidrBlockOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateSubnetCidrBlockInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateSubnetCidrBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateSubnetCidrBlock'
type EC2_DisassociateSubnetCidrBlock_Call struct {
	*mock.Call
}

// DisassociateSubnetCidrBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateSubnetCidrBlockInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateSubnetCidrBlock(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateSubnetCidrBlock_Call {
	return &EC2_DisassociateSubnetCidrBlock_Call{Call: _e.mock.On("DisassociateSubnetCidrBlock",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateSubnetCidrBlock_Call) Run(run func(ctx context.Context, params *ec2.DisassociateSubnetCidrBlockInput, optFns ...func(*ec2.Options))) *EC2_DisassociateSubnetCidrBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateSubnetCidrBlockInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateSubnetCidrBlock_Call) Return(_a0 *ec2.DisassociateSubnetCidrBlockOutput, _a1 error) *EC2_DisassociateSubnetCidrBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateSubnetCidrBlock_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateSubnetCidrBlockInput, ...func(*ec2.Options)) (*ec2.DisassociateSubnetCidrBlockOutput, error)) *EC2_DisassociateSubnetCidrBlock_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateTransitGatewayMulticastDomain provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateTransitGatewayMulticastDomain(ctx context.Context, params *ec2.DisassociateTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateTransitGatewayMulticastDomain")
	}

	var r0 *ec2.DisassociateTransitGatewayMulticastDomainOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) *ec2.DisassociateTransitGatewayMulticastDomainOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateTransitGatewayMulticastDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateTransitGatewayMulticastDomain'
type EC2_DisassociateTransitGatewayMulticastDomain_Call struct {
	*mock.Call
}

// DisassociateTransitGatewayMulticastDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateTransitGatewayMulticastDomainInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateTransitGatewayMulticastDomain(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateTransitGatewayMulticastDomain_Call {
	return &EC2_DisassociateTransitGatewayMulticastDomain_Call{Call: _e.mock.On("DisassociateTransitGatewayMulticastDomain",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateTransitGatewayMulticastDomain_Call) Run(run func(ctx context.Context, params *ec2.DisassociateTransitGatewayMulticastDomainInput, optFns ...func(*ec2.Options))) *EC2_DisassociateTransitGatewayMulticastDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateTransitGatewayMulticastDomainInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateTransitGatewayMulticastDomain_Call) Return(_a0 *ec2.DisassociateTransitGatewayMulticastDomainOutput, _a1 error) *EC2_DisassociateTransitGatewayMulticastDomain_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateTransitGatewayMulticastDomain_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateTransitGatewayMulticastDomainInput, ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error)) *EC2_DisassociateTransitGatewayMulticastDomain_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateTransitGatewayPolicyTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateTransitGatewayPolicyTable(ctx context.Context, params *ec2.DisassociateTransitGatewayPolicyTableInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateTransitGatewayPolicyTable")
	}

	var r0 *ec2.DisassociateTransitGatewayPolicyTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) *ec2.DisassociateTransitGatewayPolicyTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTransitGatewayPolicyTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateTransitGatewayPolicyTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateTransitGatewayPolicyTable'
type EC2_DisassociateTransitGatewayPolicyTable_Call struct {
	*mock.Call
}

// DisassociateTransitGatewayPolicyTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateTransitGatewayPolicyTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateTransitGatewayPolicyTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateTransitGatewayPolicyTable_Call {
	return &EC2_DisassociateTransitGatewayPolicyTable_Call{Call: _e.mock.On("DisassociateTransitGatewayPolicyTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateTransitGatewayPolicyTable_Call) Run(run func(ctx context.Context, params *ec2.DisassociateTransitGatewayPolicyTableInput, optFns ...func(*ec2.Options))) *EC2_DisassociateTransitGatewayPolicyTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateTransitGatewayPolicyTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateTransitGatewayPolicyTable_Call) Return(_a0 *ec2.DisassociateTransitGatewayPolicyTableOutput, _a1 error) *EC2_DisassociateTransitGatewayPolicyTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateTransitGatewayPolicyTable_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateTransitGatewayPolicyTableInput, ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error)) *EC2_DisassociateTransitGatewayPolicyTable_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateTransitGatewayRouteTable provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateTransitGatewayRouteTable(ctx context.Context, params *ec2.DisassociateTransitGatewayRouteTableInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateTransitGatewayRouteTable")
	}

	var r0 *ec2.DisassociateTransitGatewayRouteTableOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTransitGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayRouteTableOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTransitGatewayRouteTableInput, ...func(*ec2.Options)) *ec2.DisassociateTransitGatewayRouteTableOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTransitGatewayRouteTableOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateTransitGatewayRouteTableInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateTransitGatewayRouteTable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateTransitGatewayRouteTable'
type EC2_DisassociateTransitGatewayRouteTable_Call struct {
	*mock.Call
}

// DisassociateTransitGatewayRouteTable is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateTransitGatewayRouteTableInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateTransitGatewayRouteTable(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateTransitGatewayRouteTable_Call {
	return &EC2_DisassociateTransitGatewayRouteTable_Call{Call: _e.mock.On("DisassociateTransitGatewayRouteTable",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateTransitGatewayRouteTable_Call) Run(run func(ctx context.Context, params *ec2.DisassociateTransitGatewayRouteTableInput, optFns ...func(*ec2.Options))) *EC2_DisassociateTransitGatewayRouteTable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateTransitGatewayRouteTableInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateTransitGatewayRouteTable_Call) Return(_a0 *ec2.DisassociateTransitGatewayRouteTableOutput, _a1 error) *EC2_DisassociateTransitGatewayRouteTable_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateTransitGatewayRouteTable_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateTransitGatewayRouteTableInput, ...func(*ec2.Options)) (*ec2.DisassociateTransitGatewayRouteTableOutput, error)) *EC2_DisassociateTransitGatewayRouteTable_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateTrunkInterface provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateTrunkInterface(ctx context.Context, params *ec2.DisassociateTrunkInterfaceInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateTrunkInterfaceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateTrunkInterface")
	}

	var r0 *ec2.DisassociateTrunkInterfaceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTrunkInterfaceInput, ...func(*ec2.Options)) (*ec2.DisassociateTrunkInterfaceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateTrunkInterfaceInput, ...func(*ec2.Options)) *ec2.DisassociateTrunkInterfaceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateTrunkInterfaceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateTrunkInterfaceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateTrunkInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateTrunkInterface'
type EC2_DisassociateTrunkInterface_Call struct {
	*mock.Call
}

// DisassociateTrunkInterface is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateTrunkInterfaceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateTrunkInterface(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateTrunkInterface_Call {
	return &EC2_DisassociateTrunkInterface_Call{Call: _e.mock.On("DisassociateTrunkInterface",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateTrunkInterface_Call) Run(run func(ctx context.Context, params *ec2.DisassociateTrunkInterfaceInput, optFns ...func(*ec2.Options))) *EC2_DisassociateTrunkInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateTrunkInterfaceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateTrunkInterface_Call) Return(_a0 *ec2.DisassociateTrunkInterfaceOutput, _a1 error) *EC2_DisassociateTrunkInterface_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateTrunkInterface_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateTrunkInterfaceInput, ...func(*ec2.Options)) (*ec2.DisassociateTrunkInterfaceOutput, error)) *EC2_DisassociateTrunkInterface_Call {
	_c.Call.Return(run)
	return _c
}

// DisassociateVpcCidrBlock provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) DisassociateVpcCidrBlock(ctx context.Context, params *ec2.DisassociateVpcCidrBlockInput, optFns ...func(*ec2.Options)) (*ec2.DisassociateVpcCidrBlockOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DisassociateVpcCidrBlock")
	}

	var r0 *ec2.DisassociateVpcCidrBlockOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateVpcCidrBlockInput, ...func(*ec2.Options)) (*ec2.DisassociateVpcCidrBlockOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.DisassociateVpcCidrBlockInput, ...func(*ec2.Options)) *ec2.DisassociateVpcCidrBlockOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.DisassociateVpcCidrBlockOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.DisassociateVpcCidrBlockInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_DisassociateVpcCidrBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisassociateVpcCidrBlock'
type EC2_DisassociateVpcCidrBlock_Call struct {
	*mock.Call
}

// DisassociateVpcCidrBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.DisassociateVpcCidrBlockInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) DisassociateVpcCidrBlock(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_DisassociateVpcCidrBlock_Call {
	return &EC2_DisassociateVpcCidrBlock_Call{Call: _e.mock.On("DisassociateVpcCidrBlock",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_DisassociateVpcCidrBlock_Call) Run(run func(ctx context.Context, params *ec2.DisassociateVpcCidrBlockInput, optFns ...func(*ec2.Options))) *EC2_DisassociateVpcCidrBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.DisassociateVpcCidrBlockInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_DisassociateVpcCidrBlock_Call) Return(_a0 *ec2.DisassociateVpcCidrBlockOutput, _a1 error) *EC2_DisassociateVpcCidrBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_DisassociateVpcCidrBlock_Call) RunAndReturn(run func(context.Context, *ec2.DisassociateVpcCidrBlockInput, ...func(*ec2.Options)) (*ec2.DisassociateVpcCidrBlockOutput, error)) *EC2_DisassociateVpcCidrBlock_Call {
	_c.Call.Return(run)
	return _c
}

// EnableAddressTransfer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableAddressTransfer(ctx context.Context, params *ec2.EnableAddressTransferInput, optFns ...func(*ec2.Options)) (*ec2.EnableAddressTransferOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableAddressTransfer")
	}

	var r0 *ec2.EnableAddressTransferOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableAddressTransferInput, ...func(*ec2.Options)) (*ec2.EnableAddressTransferOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableAddressTransferInput, ...func(*ec2.Options)) *ec2.EnableAddressTransferOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableAddressTransferOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableAddressTransferInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableAddressTransfer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableAddressTransfer'
type EC2_EnableAddressTransfer_Call struct {
	*mock.Call
}

// EnableAddressTransfer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableAddressTransferInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableAddressTransfer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableAddressTransfer_Call {
	return &EC2_EnableAddressTransfer_Call{Call: _e.mock.On("EnableAddressTransfer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableAddressTransfer_Call) Run(run func(ctx context.Context, params *ec2.EnableAddressTransferInput, optFns ...func(*ec2.Options))) *EC2_EnableAddressTransfer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableAddressTransferInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableAddressTransfer_Call) Return(_a0 *ec2.EnableAddressTransferOutput, _a1 error) *EC2_EnableAddressTransfer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableAddressTransfer_Call) RunAndReturn(run func(context.Context, *ec2.EnableAddressTransferInput, ...func(*ec2.Options)) (*ec2.EnableAddressTransferOutput, error)) *EC2_EnableAddressTransfer_Call {
	_c.Call.Return(run)
	return _c
}

// EnableAllowedImagesSettings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableAllowedImagesSettings(ctx context.Context, params *ec2.EnableAllowedImagesSettingsInput, optFns ...func(*ec2.Options)) (*ec2.EnableAllowedImagesSettingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableAllowedImagesSettings")
	}

	var r0 *ec2.EnableAllowedImagesSettingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableAllowedImagesSettingsInput, ...func(*ec2.Options)) (*ec2.EnableAllowedImagesSettingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableAllowedImagesSettingsInput, ...func(*ec2.Options)) *ec2.EnableAllowedImagesSettingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableAllowedImagesSettingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableAllowedImagesSettingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableAllowedImagesSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableAllowedImagesSettings'
type EC2_EnableAllowedImagesSettings_Call struct {
	*mock.Call
}

// EnableAllowedImagesSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableAllowedImagesSettingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableAllowedImagesSettings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableAllowedImagesSettings_Call {
	return &EC2_EnableAllowedImagesSettings_Call{Call: _e.mock.On("EnableAllowedImagesSettings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableAllowedImagesSettings_Call) Run(run func(ctx context.Context, params *ec2.EnableAllowedImagesSettingsInput, optFns ...func(*ec2.Options))) *EC2_EnableAllowedImagesSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableAllowedImagesSettingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableAllowedImagesSettings_Call) Return(_a0 *ec2.EnableAllowedImagesSettingsOutput, _a1 error) *EC2_EnableAllowedImagesSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableAllowedImagesSettings_Call) RunAndReturn(run func(context.Context, *ec2.EnableAllowedImagesSettingsInput, ...func(*ec2.Options)) (*ec2.EnableAllowedImagesSettingsOutput, error)) *EC2_EnableAllowedImagesSettings_Call {
	_c.Call.Return(run)
	return _c
}

// EnableAwsNetworkPerformanceMetricSubscription provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableAwsNetworkPerformanceMetricSubscription(ctx context.Context, params *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, optFns ...func(*ec2.Options)) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableAwsNetworkPerformanceMetricSubscription")
	}

	var r0 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, ...func(*ec2.Options)) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, ...func(*ec2.Options)) *ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableAwsNetworkPerformanceMetricSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableAwsNetworkPerformanceMetricSubscription'
type EC2_EnableAwsNetworkPerformanceMetricSubscription_Call struct {
	*mock.Call
}

// EnableAwsNetworkPerformanceMetricSubscription is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableAwsNetworkPerformanceMetricSubscription(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableAwsNetworkPerformanceMetricSubscription_Call {
	return &EC2_EnableAwsNetworkPerformanceMetricSubscription_Call{Call: _e.mock.On("EnableAwsNetworkPerformanceMetricSubscription",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableAwsNetworkPerformanceMetricSubscription_Call) Run(run func(ctx context.Context, params *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, optFns ...func(*ec2.Options))) *EC2_EnableAwsNetworkPerformanceMetricSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableAwsNetworkPerformanceMetricSubscription_Call) Return(_a0 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, _a1 error) *EC2_EnableAwsNetworkPerformanceMetricSubscription_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableAwsNetworkPerformanceMetricSubscription_Call) RunAndReturn(run func(context.Context, *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, ...func(*ec2.Options)) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error)) *EC2_EnableAwsNetworkPerformanceMetricSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// EnableCapacityManager provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableCapacityManager(ctx context.Context, params *ec2.EnableCapacityManagerInput, optFns ...func(*ec2.Options)) (*ec2.EnableCapacityManagerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableCapacityManager")
	}

	var r0 *ec2.EnableCapacityManagerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableCapacityManagerInput, ...func(*ec2.Options)) (*ec2.EnableCapacityManagerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableCapacityManagerInput, ...func(*ec2.Options)) *ec2.EnableCapacityManagerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableCapacityManagerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableCapacityManagerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableCapacityManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableCapacityManager'
type EC2_EnableCapacityManager_Call struct {
	*mock.Call
}

// EnableCapacityManager is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableCapacityManagerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableCapacityManager(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableCapacityManager_Call {
	return &EC2_EnableCapacityManager_Call{Call: _e.mock.On("EnableCapacityManager",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableCapacityManager_Call) Run(run func(ctx context.Context, params *ec2.EnableCapacityManagerInput, optFns ...func(*ec2.Options))) *EC2_EnableCapacityManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableCapacityManagerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableCapacityManager_Call) Return(_a0 *ec2.EnableCapacityManagerOutput, _a1 error) *EC2_EnableCapacityManager_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableCapacityManager_Call) RunAndReturn(run func(context.Context, *ec2.EnableCapacityManagerInput, ...func(*ec2.Options)) (*ec2.EnableCapacityManagerOutput, error)) *EC2_EnableCapacityManager_Call {
	_c.Call.Return(run)
	return _c
}

// EnableEbsEncryptionByDefault provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableEbsEncryptionByDefault(ctx context.Context, params *ec2.EnableEbsEncryptionByDefaultInput, optFns ...func(*ec2.Options)) (*ec2.EnableEbsEncryptionByDefaultOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableEbsEncryptionByDefault")
	}

	var r0 *ec2.EnableEbsEncryptionByDefaultOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableEbsEncryptionByDefaultInput, ...func(*ec2.Options)) (*ec2.EnableEbsEncryptionByDefaultOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableEbsEncryptionByDefaultInput, ...func(*ec2.Options)) *ec2.EnableEbsEncryptionByDefaultOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableEbsEncryptionByDefaultOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableEbsEncryptionByDefaultInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableEbsEncryptionByDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableEbsEncryptionByDefault'
type EC2_EnableEbsEncryptionByDefault_Call struct {
	*mock.Call
}

// EnableEbsEncryptionByDefault is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableEbsEncryptionByDefaultInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableEbsEncryptionByDefault(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableEbsEncryptionByDefault_Call {
	return &EC2_EnableEbsEncryptionByDefault_Call{Call: _e.mock.On("EnableEbsEncryptionByDefault",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableEbsEncryptionByDefault_Call) Run(run func(ctx context.Context, params *ec2.EnableEbsEncryptionByDefaultInput, optFns ...func(*ec2.Options))) *EC2_EnableEbsEncryptionByDefault_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableEbsEncryptionByDefaultInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableEbsEncryptionByDefault_Call) Return(_a0 *ec2.EnableEbsEncryptionByDefaultOutput, _a1 error) *EC2_EnableEbsEncryptionByDefault_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableEbsEncryptionByDefault_Call) RunAndReturn(run func(context.Context, *ec2.EnableEbsEncryptionByDefaultInput, ...func(*ec2.Options)) (*ec2.EnableEbsEncryptionByDefaultOutput, error)) *EC2_EnableEbsEncryptionByDefault_Call {
	_c.Call.Return(run)
	return _c
}

// EnableFastLaunch provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableFastLaunch(ctx context.Context, params *ec2.EnableFastLaunchInput, optFns ...func(*ec2.Options)) (*ec2.EnableFastLaunchOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableFastLaunch")
	}

	var r0 *ec2.EnableFastLaunchOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableFastLaunchInput, ...func(*ec2.Options)) (*ec2.EnableFastLaunchOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableFastLaunchInput, ...func(*ec2.Options)) *ec2.EnableFastLaunchOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableFastLaunchOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableFastLaunchInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableFastLaunch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableFastLaunch'
type EC2_EnableFastLaunch_Call struct {
	*mock.Call
}

// EnableFastLaunch is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableFastLaunchInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableFastLaunch(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableFastLaunch_Call {
	return &EC2_EnableFastLaunch_Call{Call: _e.mock.On("EnableFastLaunch",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableFastLaunch_Call) Run(run func(ctx context.Context, params *ec2.EnableFastLaunchInput, optFns ...func(*ec2.Options))) *EC2_EnableFastLaunch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableFastLaunchInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableFastLaunch_Call) Return(_a0 *ec2.EnableFastLaunchOutput, _a1 error) *EC2_EnableFastLaunch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableFastLaunch_Call) RunAndReturn(run func(context.Context, *ec2.EnableFastLaunchInput, ...func(*ec2.Options)) (*ec2.EnableFastLaunchOutput, error)) *EC2_EnableFastLaunch_Call {
	_c.Call.Return(run)
	return _c
}

// EnableFastSnapshotRestores provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableFastSnapshotRestores(ctx context.Context, params *ec2.EnableFastSnapshotRestoresInput, optFns ...func(*ec2.Options)) (*ec2.EnableFastSnapshotRestoresOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableFastSnapshotRestores")
	}

	var r0 *ec2.EnableFastSnapshotRestoresOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableFastSnapshotRestoresInput, ...func(*ec2.Options)) (*ec2.EnableFastSnapshotRestoresOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableFastSnapshotRestoresInput, ...func(*ec2.Options)) *ec2.EnableFastSnapshotRestoresOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableFastSnapshotRestoresOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableFastSnapshotRestoresInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableFastSnapshotRestores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableFastSnapshotRestores'
type EC2_EnableFastSnapshotRestores_Call struct {
	*mock.Call
}

// EnableFastSnapshotRestores is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableFastSnapshotRestoresInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableFastSnapshotRestores(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableFastSnapshotRestores_Call {
	return &EC2_EnableFastSnapshotRestores_Call{Call: _e.mock.On("EnableFastSnapshotRestores",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableFastSnapshotRestores_Call) Run(run func(ctx context.Context, params *ec2.EnableFastSnapshotRestoresInput, optFns ...func(*ec2.Options))) *EC2_EnableFastSnapshotRestores_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableFastSnapshotRestoresInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableFastSnapshotRestores_Call) Return(_a0 *ec2.EnableFastSnapshotRestoresOutput, _a1 error) *EC2_EnableFastSnapshotRestores_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableFastSnapshotRestores_Call) RunAndReturn(run func(context.Context, *ec2.EnableFastSnapshotRestoresInput, ...func(*ec2.Options)) (*ec2.EnableFastSnapshotRestoresOutput, error)) *EC2_EnableFastSnapshotRestores_Call {
	_c.Call.Return(run)
	return _c
}

// EnableImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableImage(ctx context.Context, params *ec2.EnableImageInput, optFns ...func(*ec2.Options)) (*ec2.EnableImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableImage")
	}

	var r0 *ec2.EnableImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageInput, ...func(*ec2.Options)) (*ec2.EnableImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageInput, ...func(*ec2.Options)) *ec2.EnableImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableImage'
type EC2_EnableImage_Call struct {
	*mock.Call
}

// EnableImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableImage_Call {
	return &EC2_EnableImage_Call{Call: _e.mock.On("EnableImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableImage_Call) Run(run func(ctx context.Context, params *ec2.EnableImageInput, optFns ...func(*ec2.Options))) *EC2_EnableImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableImage_Call) Return(_a0 *ec2.EnableImageOutput, _a1 error) *EC2_EnableImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableImage_Call) RunAndReturn(run func(context.Context, *ec2.EnableImageInput, ...func(*ec2.Options)) (*ec2.EnableImageOutput, error)) *EC2_EnableImage_Call {
	_c.Call.Return(run)
	return _c
}

// EnableImageBlockPublicAccess provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableImageBlockPublicAccess(ctx context.Context, params *ec2.EnableImageBlockPublicAccessInput, optFns ...func(*ec2.Options)) (*ec2.EnableImageBlockPublicAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableImageBlockPublicAccess")
	}

	var r0 *ec2.EnableImageBlockPublicAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageBlockPublicAccessInput, ...func(*ec2.Options)) (*ec2.EnableImageBlockPublicAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageBlockPublicAccessInput, ...func(*ec2.Options)) *ec2.EnableImageBlockPublicAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableImageBlockPublicAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableImageBlockPublicAccessInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableImageBlockPublicAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableImageBlockPublicAccess'
type EC2_EnableImageBlockPublicAccess_Call struct {
	*mock.Call
}

// EnableImageBlockPublicAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableImageBlockPublicAccessInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableImageBlockPublicAccess(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableImageBlockPublicAccess_Call {
	return &EC2_EnableImageBlockPublicAccess_Call{Call: _e.mock.On("EnableImageBlockPublicAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableImageBlockPublicAccess_Call) Run(run func(ctx context.Context, params *ec2.EnableImageBlockPublicAccessInput, optFns ...func(*ec2.Options))) *EC2_EnableImageBlockPublicAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableImageBlockPublicAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableImageBlockPublicAccess_Call) Return(_a0 *ec2.EnableImageBlockPublicAccessOutput, _a1 error) *EC2_EnableImageBlockPublicAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableImageBlockPublicAccess_Call) RunAndReturn(run func(context.Context, *ec2.EnableImageBlockPublicAccessInput, ...func(*ec2.Options)) (*ec2.EnableImageBlockPublicAccessOutput, error)) *EC2_EnableImageBlockPublicAccess_Call {
	_c.Call.Return(run)
	return _c
}

// EnableImageDeprecation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableImageDeprecation(ctx context.Context, params *ec2.EnableImageDeprecationInput, optFns ...func(*ec2.Options)) (*ec2.EnableImageDeprecationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableImageDeprecation")
	}

	var r0 *ec2.EnableImageDeprecationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageDeprecationInput, ...func(*ec2.Options)) (*ec2.EnableImageDeprecationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageDeprecationInput, ...func(*ec2.Options)) *ec2.EnableImageDeprecationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableImageDeprecationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableImageDeprecationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableImageDeprecation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableImageDeprecation'
type EC2_EnableImageDeprecation_Call struct {
	*mock.Call
}

// EnableImageDeprecation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableImageDeprecationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableImageDeprecation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableImageDeprecation_Call {
	return &EC2_EnableImageDeprecation_Call{Call: _e.mock.On("EnableImageDeprecation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableImageDeprecation_Call) Run(run func(ctx context.Context, params *ec2.EnableImageDeprecationInput, optFns ...func(*ec2.Options))) *EC2_EnableImageDeprecation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableImageDeprecationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableImageDeprecation_Call) Return(_a0 *ec2.EnableImageDeprecationOutput, _a1 error) *EC2_EnableImageDeprecation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableImageDeprecation_Call) RunAndReturn(run func(context.Context, *ec2.EnableImageDeprecationInput, ...func(*ec2.Options)) (*ec2.EnableImageDeprecationOutput, error)) *EC2_EnableImageDeprecation_Call {
	_c.Call.Return(run)
	return _c
}

// EnableImageDeregistrationProtection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableImageDeregistrationProtection(ctx context.Context, params *ec2.EnableImageDeregistrationProtectionInput, optFns ...func(*ec2.Options)) (*ec2.EnableImageDeregistrationProtectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableImageDeregistrationProtection")
	}

	var r0 *ec2.EnableImageDeregistrationProtectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageDeregistrationProtectionInput, ...func(*ec2.Options)) (*ec2.EnableImageDeregistrationProtectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableImageDeregistrationProtectionInput, ...func(*ec2.Options)) *ec2.EnableImageDeregistrationProtectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableImageDeregistrationProtectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableImageDeregistrationProtectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableImageDeregistrationProtection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableImageDeregistrationProtection'
type EC2_EnableImageDeregistrationProtection_Call struct {
	*mock.Call
}

// EnableImageDeregistrationProtection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableImageDeregistrationProtectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableImageDeregistrationProtection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableImageDeregistrationProtection_Call {
	return &EC2_EnableImageDeregistrationProtection_Call{Call: _e.mock.On("EnableImageDeregistrationProtection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableImageDeregistrationProtection_Call) Run(run func(ctx context.Context, params *ec2.EnableImageDeregistrationProtectionInput, optFns ...func(*ec2.Options))) *EC2_EnableImageDeregistrationProtection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableImageDeregistrationProtectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableImageDeregistrationProtection_Call) Return(_a0 *ec2.EnableImageDeregistrationProtectionOutput, _a1 error) *EC2_EnableImageDeregistrationProtection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableImageDeregistrationProtection_Call) RunAndReturn(run func(context.Context, *ec2.EnableImageDeregistrationProtectionInput, ...func(*ec2.Options)) (*ec2.EnableImageDeregistrationProtectionOutput, error)) *EC2_EnableImageDeregistrationProtection_Call {
	_c.Call.Return(run)
	return _c
}

// EnableInstanceSqlHaStandbyDetections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableInstanceSqlHaStandbyDetections(ctx context.Context, params *ec2.EnableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*ec2.Options)) (*ec2.EnableInstanceSqlHaStandbyDetectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableInstanceSqlHaStandbyDetections")
	}

	var r0 *ec2.EnableInstanceSqlHaStandbyDetectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) (*ec2.EnableInstanceSqlHaStandbyDetectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) *ec2.EnableInstanceSqlHaStandbyDetectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableInstanceSqlHaStandbyDetectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableInstanceSqlHaStandbyDetections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableInstanceSqlHaStandbyDetections'
type EC2_EnableInstanceSqlHaStandbyDetections_Call struct {
	*mock.Call
}

// EnableInstanceSqlHaStandbyDetections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableInstanceSqlHaStandbyDetectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableInstanceSqlHaStandbyDetections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableInstanceSqlHaStandbyDetections_Call {
	return &EC2_EnableInstanceSqlHaStandbyDetections_Call{Call: _e.mock.On("EnableInstanceSqlHaStandbyDetections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableInstanceSqlHaStandbyDetections_Call) Run(run func(ctx context.Context, params *ec2.EnableInstanceSqlHaStandbyDetectionsInput, optFns ...func(*ec2.Options))) *EC2_EnableInstanceSqlHaStandbyDetections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableInstanceSqlHaStandbyDetectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableInstanceSqlHaStandbyDetections_Call) Return(_a0 *ec2.EnableInstanceSqlHaStandbyDetectionsOutput, _a1 error) *EC2_EnableInstanceSqlHaStandbyDetections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableInstanceSqlHaStandbyDetections_Call) RunAndReturn(run func(context.Context, *ec2.EnableInstanceSqlHaStandbyDetectionsInput, ...func(*ec2.Options)) (*ec2.EnableInstanceSqlHaStandbyDetectionsOutput, error)) *EC2_EnableInstanceSqlHaStandbyDetections_Call {
	_c.Call.Return(run)
	return _c
}

// EnableIpamOrganizationAdminAccount provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableIpamOrganizationAdminAccount(ctx context.Context, params *ec2.EnableIpamOrganizationAdminAccountInput, optFns ...func(*ec2.Options)) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableIpamOrganizationAdminAccount")
	}

	var r0 *ec2.EnableIpamOrganizationAdminAccountOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableIpamOrganizationAdminAccountInput, ...func(*ec2.Options)) (*ec2.EnableIpamOrganizationAdminAccountOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableIpamOrganizationAdminAccountInput, ...func(*ec2.Options)) *ec2.EnableIpamOrganizationAdminAccountOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableIpamOrganizationAdminAccountOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableIpamOrganizationAdminAccountInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableIpamOrganizationAdminAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableIpamOrganizationAdminAccount'
type EC2_EnableIpamOrganizationAdminAccount_Call struct {
	*mock.Call
}

// EnableIpamOrganizationAdminAccount is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableIpamOrganizationAdminAccountInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableIpamOrganizationAdminAccount(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableIpamOrganizationAdminAccount_Call {
	return &EC2_EnableIpamOrganizationAdminAccount_Call{Call: _e.mock.On("EnableIpamOrganizationAdminAccount",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableIpamOrganizationAdminAccount_Call) Run(run func(ctx context.Context, params *ec2.EnableIpamOrganizationAdminAccountInput, optFns ...func(*ec2.Options))) *EC2_EnableIpamOrganizationAdminAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableIpamOrganizationAdminAccountInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableIpamOrganizationAdminAccount_Call) Return(_a0 *ec2.EnableIpamOrganizationAdminAccountOutput, _a1 error) *EC2_EnableIpamOrganizationAdminAccount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableIpamOrganizationAdminAccount_Call) RunAndReturn(run func(context.Context, *ec2.EnableIpamOrganizationAdminAccountInput, ...func(*ec2.Options)) (*ec2.EnableIpamOrganizationAdminAccountOutput, error)) *EC2_EnableIpamOrganizationAdminAccount_Call {
	_c.Call.Return(run)
	return _c
}

// EnableIpamPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableIpamPolicy(ctx context.Context, params *ec2.EnableIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.EnableIpamPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableIpamPolicy")
	}

	var r0 *ec2.EnableIpamPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableIpamPolicyInput, ...func(*ec2.Options)) (*ec2.EnableIpamPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableIpamPolicyInput, ...func(*ec2.Options)) *ec2.EnableIpamPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableIpamPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableIpamPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableIpamPolicy'
type EC2_EnableIpamPolicy_Call struct {
	*mock.Call
}

// EnableIpamPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableIpamPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableIpamPolicy_Call {
	return &EC2_EnableIpamPolicy_Call{Call: _e.mock.On("EnableIpamPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.EnableIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_EnableIpamPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableIpamPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableIpamPolicy_Call) Return(_a0 *ec2.EnableIpamPolicyOutput, _a1 error) *EC2_EnableIpamPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.EnableIpamPolicyInput, ...func(*ec2.Options)) (*ec2.EnableIpamPolicyOutput, error)) *EC2_EnableIpamPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// EnableReachabilityAnalyzerOrganizationSharing provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableReachabilityAnalyzerOrganizationSharing(ctx context.Context, params *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, optFns ...func(*ec2.Options)) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableReachabilityAnalyzerOrganizationSharing")
	}

	var r0 *ec2.EnableReachabilityAnalyzerOrganizationSharingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, ...func(*ec2.Options)) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, ...func(*ec2.Options)) *ec2.EnableReachabilityAnalyzerOrganizationSharingOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableReachabilityAnalyzerOrganizationSharing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableReachabilityAnalyzerOrganizationSharing'
type EC2_EnableReachabilityAnalyzerOrganizationSharing_Call struct {
	*mock.Call
}

// EnableReachabilityAnalyzerOrganizationSharing is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableReachabilityAnalyzerOrganizationSharingInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableReachabilityAnalyzerOrganizationSharing(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableReachabilityAnalyzerOrganizationSharing_Call {
	return &EC2_EnableReachabilityAnalyzerOrganizationSharing_Call{Call: _e.mock.On("EnableReachabilityAnalyzerOrganizationSharing",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableReachabilityAnalyzerOrganizationSharing_Call) Run(run func(ctx context.Context, params *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, optFns ...func(*ec2.Options))) *EC2_EnableReachabilityAnalyzerOrganizationSharing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableReachabilityAnalyzerOrganizationSharingInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableReachabilityAnalyzerOrganizationSharing_Call) Return(_a0 *ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, _a1 error) *EC2_EnableReachabilityAnalyzerOrganizationSharing_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableReachabilityAnalyzerOrganizationSharing_Call) RunAndReturn(run func(context.Context, *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, ...func(*ec2.Options)) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error)) *EC2_EnableReachabilityAnalyzerOrganizationSharing_Call {
	_c.Call.Return(run)
	return _c
}

// EnableRouteServerPropagation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableRouteServerPropagation(ctx context.Context, params *ec2.EnableRouteServerPropagationInput, optFns ...func(*ec2.Options)) (*ec2.EnableRouteServerPropagationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableRouteServerPropagation")
	}

	var r0 *ec2.EnableRouteServerPropagationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableRouteServerPropagationInput, ...func(*ec2.Options)) (*ec2.EnableRouteServerPropagationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableRouteServerPropagationInput, ...func(*ec2.Options)) *ec2.EnableRouteServerPropagationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableRouteServerPropagationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableRouteServerPropagationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableRouteServerPropagation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableRouteServerPropagation'
type EC2_EnableRouteServerPropagation_Call struct {
	*mock.Call
}

// EnableRouteServerPropagation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableRouteServerPropagationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableRouteServerPropagation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableRouteServerPropagation_Call {
	return &EC2_EnableRouteServerPropagation_Call{Call: _e.mock.On("EnableRouteServerPropagation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableRouteServerPropagation_Call) Run(run func(ctx context.Context, params *ec2.EnableRouteServerPropagationInput, optFns ...func(*ec2.Options))) *EC2_EnableRouteServerPropagation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableRouteServerPropagationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableRouteServerPropagation_Call) Return(_a0 *ec2.EnableRouteServerPropagationOutput, _a1 error) *EC2_EnableRouteServerPropagation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableRouteServerPropagation_Call) RunAndReturn(run func(context.Context, *ec2.EnableRouteServerPropagationInput, ...func(*ec2.Options)) (*ec2.EnableRouteServerPropagationOutput, error)) *EC2_EnableRouteServerPropagation_Call {
	_c.Call.Return(run)
	return _c
}

// EnableSerialConsoleAccess provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableSerialConsoleAccess(ctx context.Context, params *ec2.EnableSerialConsoleAccessInput, optFns ...func(*ec2.Options)) (*ec2.EnableSerialConsoleAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableSerialConsoleAccess")
	}

	var r0 *ec2.EnableSerialConsoleAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableSerialConsoleAccessInput, ...func(*ec2.Options)) (*ec2.EnableSerialConsoleAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableSerialConsoleAccessInput, ...func(*ec2.Options)) *ec2.EnableSerialConsoleAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableSerialConsoleAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableSerialConsoleAccessInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableSerialConsoleAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableSerialConsoleAccess'
type EC2_EnableSerialConsoleAccess_Call struct {
	*mock.Call
}

// EnableSerialConsoleAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableSerialConsoleAccessInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableSerialConsoleAccess(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableSerialConsoleAccess_Call {
	return &EC2_EnableSerialConsoleAccess_Call{Call: _e.mock.On("EnableSerialConsoleAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableSerialConsoleAccess_Call) Run(run func(ctx context.Context, params *ec2.EnableSerialConsoleAccessInput, optFns ...func(*ec2.Options))) *EC2_EnableSerialConsoleAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableSerialConsoleAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableSerialConsoleAccess_Call) Return(_a0 *ec2.EnableSerialConsoleAccessOutput, _a1 error) *EC2_EnableSerialConsoleAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableSerialConsoleAccess_Call) RunAndReturn(run func(context.Context, *ec2.EnableSerialConsoleAccessInput, ...func(*ec2.Options)) (*ec2.EnableSerialConsoleAccessOutput, error)) *EC2_EnableSerialConsoleAccess_Call {
	_c.Call.Return(run)
	return _c
}

// EnableSnapshotBlockPublicAccess provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableSnapshotBlockPublicAccess(ctx context.Context, params *ec2.EnableSnapshotBlockPublicAccessInput, optFns ...func(*ec2.Options)) (*ec2.EnableSnapshotBlockPublicAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableSnapshotBlockPublicAccess")
	}

	var r0 *ec2.EnableSnapshotBlockPublicAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableSnapshotBlockPublicAccessInput, ...func(*ec2.Options)) (*ec2.EnableSnapshotBlockPublicAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableSnapshotBlockPublicAccessInput, ...func(*ec2.Options)) *ec2.EnableSnapshotBlockPublicAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableSnapshotBlockPublicAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableSnapshotBlockPublicAccessInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableSnapshotBlockPublicAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableSnapshotBlockPublicAccess'
type EC2_EnableSnapshotBlockPublicAccess_Call struct {
	*mock.Call
}

// EnableSnapshotBlockPublicAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableSnapshotBlockPublicAccessInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableSnapshotBlockPublicAccess(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableSnapshotBlockPublicAccess_Call {
	return &EC2_EnableSnapshotBlockPublicAccess_Call{Call: _e.mock.On("EnableSnapshotBlockPublicAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableSnapshotBlockPublicAccess_Call) Run(run func(ctx context.Context, params *ec2.EnableSnapshotBlockPublicAccessInput, optFns ...func(*ec2.Options))) *EC2_EnableSnapshotBlockPublicAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableSnapshotBlockPublicAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableSnapshotBlockPublicAccess_Call) Return(_a0 *ec2.EnableSnapshotBlockPublicAccessOutput, _a1 error) *EC2_EnableSnapshotBlockPublicAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableSnapshotBlockPublicAccess_Call) RunAndReturn(run func(context.Context, *ec2.EnableSnapshotBlockPublicAccessInput, ...func(*ec2.Options)) (*ec2.EnableSnapshotBlockPublicAccessOutput, error)) *EC2_EnableSnapshotBlockPublicAccess_Call {
	_c.Call.Return(run)
	return _c
}

// EnableTransitGatewayRouteTablePropagation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableTransitGatewayRouteTablePropagation(ctx context.Context, params *ec2.EnableTransitGatewayRouteTablePropagationInput, optFns ...func(*ec2.Options)) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableTransitGatewayRouteTablePropagation")
	}

	var r0 *ec2.EnableTransitGatewayRouteTablePropagationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableTransitGatewayRouteTablePropagationInput, ...func(*ec2.Options)) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableTransitGatewayRouteTablePropagationInput, ...func(*ec2.Options)) *ec2.EnableTransitGatewayRouteTablePropagationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableTransitGatewayRouteTablePropagationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableTransitGatewayRouteTablePropagation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableTransitGatewayRouteTablePropagation'
type EC2_EnableTransitGatewayRouteTablePropagation_Call struct {
	*mock.Call
}

// EnableTransitGatewayRouteTablePropagation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableTransitGatewayRouteTablePropagationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableTransitGatewayRouteTablePropagation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableTransitGatewayRouteTablePropagation_Call {
	return &EC2_EnableTransitGatewayRouteTablePropagation_Call{Call: _e.mock.On("EnableTransitGatewayRouteTablePropagation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableTransitGatewayRouteTablePropagation_Call) Run(run func(ctx context.Context, params *ec2.EnableTransitGatewayRouteTablePropagationInput, optFns ...func(*ec2.Options))) *EC2_EnableTransitGatewayRouteTablePropagation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableTransitGatewayRouteTablePropagationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableTransitGatewayRouteTablePropagation_Call) Return(_a0 *ec2.EnableTransitGatewayRouteTablePropagationOutput, _a1 error) *EC2_EnableTransitGatewayRouteTablePropagation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableTransitGatewayRouteTablePropagation_Call) RunAndReturn(run func(context.Context, *ec2.EnableTransitGatewayRouteTablePropagationInput, ...func(*ec2.Options)) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error)) *EC2_EnableTransitGatewayRouteTablePropagation_Call {
	_c.Call.Return(run)
	return _c
}

// EnableVgwRoutePropagation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableVgwRoutePropagation(ctx context.Context, params *ec2.EnableVgwRoutePropagationInput, optFns ...func(*ec2.Options)) (*ec2.EnableVgwRoutePropagationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableVgwRoutePropagation")
	}

	var r0 *ec2.EnableVgwRoutePropagationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVgwRoutePropagationInput, ...func(*ec2.Options)) (*ec2.EnableVgwRoutePropagationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVgwRoutePropagationInput, ...func(*ec2.Options)) *ec2.EnableVgwRoutePropagationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVgwRoutePropagationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableVgwRoutePropagationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableVgwRoutePropagation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableVgwRoutePropagation'
type EC2_EnableVgwRoutePropagation_Call struct {
	*mock.Call
}

// EnableVgwRoutePropagation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableVgwRoutePropagationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableVgwRoutePropagation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableVgwRoutePropagation_Call {
	return &EC2_EnableVgwRoutePropagation_Call{Call: _e.mock.On("EnableVgwRoutePropagation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableVgwRoutePropagation_Call) Run(run func(ctx context.Context, params *ec2.EnableVgwRoutePropagationInput, optFns ...func(*ec2.Options))) *EC2_EnableVgwRoutePropagation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableVgwRoutePropagationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableVgwRoutePropagation_Call) Return(_a0 *ec2.EnableVgwRoutePropagationOutput, _a1 error) *EC2_EnableVgwRoutePropagation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableVgwRoutePropagation_Call) RunAndReturn(run func(context.Context, *ec2.EnableVgwRoutePropagationInput, ...func(*ec2.Options)) (*ec2.EnableVgwRoutePropagationOutput, error)) *EC2_EnableVgwRoutePropagation_Call {
	_c.Call.Return(run)
	return _c
}

// EnableVolumeIO provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableVolumeIO(ctx context.Context, params *ec2.EnableVolumeIOInput, optFns ...func(*ec2.Options)) (*ec2.EnableVolumeIOOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableVolumeIO")
	}

	var r0 *ec2.EnableVolumeIOOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVolumeIOInput, ...func(*ec2.Options)) (*ec2.EnableVolumeIOOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVolumeIOInput, ...func(*ec2.Options)) *ec2.EnableVolumeIOOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVolumeIOOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableVolumeIOInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableVolumeIO_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableVolumeIO'
type EC2_EnableVolumeIO_Call struct {
	*mock.Call
}

// EnableVolumeIO is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableVolumeIOInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableVolumeIO(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableVolumeIO_Call {
	return &EC2_EnableVolumeIO_Call{Call: _e.mock.On("EnableVolumeIO",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableVolumeIO_Call) Run(run func(ctx context.Context, params *ec2.EnableVolumeIOInput, optFns ...func(*ec2.Options))) *EC2_EnableVolumeIO_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableVolumeIOInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableVolumeIO_Call) Return(_a0 *ec2.EnableVolumeIOOutput, _a1 error) *EC2_EnableVolumeIO_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableVolumeIO_Call) RunAndReturn(run func(context.Context, *ec2.EnableVolumeIOInput, ...func(*ec2.Options)) (*ec2.EnableVolumeIOOutput, error)) *EC2_EnableVolumeIO_Call {
	_c.Call.Return(run)
	return _c
}

// EnableVpcClassicLink provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableVpcClassicLink(ctx context.Context, params *ec2.EnableVpcClassicLinkInput, optFns ...func(*ec2.Options)) (*ec2.EnableVpcClassicLinkOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableVpcClassicLink")
	}

	var r0 *ec2.EnableVpcClassicLinkOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVpcClassicLinkInput, ...func(*ec2.Options)) (*ec2.EnableVpcClassicLinkOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVpcClassicLinkInput, ...func(*ec2.Options)) *ec2.EnableVpcClassicLinkOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVpcClassicLinkOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableVpcClassicLinkInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableVpcClassicLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableVpcClassicLink'
type EC2_EnableVpcClassicLink_Call struct {
	*mock.Call
}

// EnableVpcClassicLink is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableVpcClassicLinkInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableVpcClassicLink(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableVpcClassicLink_Call {
	return &EC2_EnableVpcClassicLink_Call{Call: _e.mock.On("EnableVpcClassicLink",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableVpcClassicLink_Call) Run(run func(ctx context.Context, params *ec2.EnableVpcClassicLinkInput, optFns ...func(*ec2.Options))) *EC2_EnableVpcClassicLink_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableVpcClassicLinkInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableVpcClassicLink_Call) Return(_a0 *ec2.EnableVpcClassicLinkOutput, _a1 error) *EC2_EnableVpcClassicLink_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableVpcClassicLink_Call) RunAndReturn(run func(context.Context, *ec2.EnableVpcClassicLinkInput, ...func(*ec2.Options)) (*ec2.EnableVpcClassicLinkOutput, error)) *EC2_EnableVpcClassicLink_Call {
	_c.Call.Return(run)
	return _c
}

// EnableVpcClassicLinkDnsSupport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) EnableVpcClassicLinkDnsSupport(ctx context.Context, params *ec2.EnableVpcClassicLinkDnsSupportInput, optFns ...func(*ec2.Options)) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EnableVpcClassicLinkDnsSupport")
	}

	var r0 *ec2.EnableVpcClassicLinkDnsSupportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.EnableVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) *ec2.EnableVpcClassicLinkDnsSupportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.EnableVpcClassicLinkDnsSupportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.EnableVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_EnableVpcClassicLinkDnsSupport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableVpcClassicLinkDnsSupport'
type EC2_EnableVpcClassicLinkDnsSupport_Call struct {
	*mock.Call
}

// EnableVpcClassicLinkDnsSupport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.EnableVpcClassicLinkDnsSupportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) EnableVpcClassicLinkDnsSupport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_EnableVpcClassicLinkDnsSupport_Call {
	return &EC2_EnableVpcClassicLinkDnsSupport_Call{Call: _e.mock.On("EnableVpcClassicLinkDnsSupport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_EnableVpcClassicLinkDnsSupport_Call) Run(run func(ctx context.Context, params *ec2.EnableVpcClassicLinkDnsSupportInput, optFns ...func(*ec2.Options))) *EC2_EnableVpcClassicLinkDnsSupport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.EnableVpcClassicLinkDnsSupportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_EnableVpcClassicLinkDnsSupport_Call) Return(_a0 *ec2.EnableVpcClassicLinkDnsSupportOutput, _a1 error) *EC2_EnableVpcClassicLinkDnsSupport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_EnableVpcClassicLinkDnsSupport_Call) RunAndReturn(run func(context.Context, *ec2.EnableVpcClassicLinkDnsSupportInput, ...func(*ec2.Options)) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error)) *EC2_EnableVpcClassicLinkDnsSupport_Call {
	_c.Call.Return(run)
	return _c
}

// ExportClientVpnClientCertificateRevocationList provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ExportClientVpnClientCertificateRevocationList(ctx context.Context, params *ec2.ExportClientVpnClientCertificateRevocationListInput, optFns ...func(*ec2.Options)) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ExportClientVpnClientCertificateRevocationList")
	}

	var r0 *ec2.ExportClientVpnClientCertificateRevocationListOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportClientVpnClientCertificateRevocationListInput, ...func(*ec2.Options)) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportClientVpnClientCertificateRevocationListInput, ...func(*ec2.Options)) *ec2.ExportClientVpnClientCertificateRevocationListOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportClientVpnClientCertificateRevocationListInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ExportClientVpnClientCertificateRevocationList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExportClientVpnClientCertificateRevocationList'
type EC2_ExportClientVpnClientCertificateRevocationList_Call struct {
	*mock.Call
}

// ExportClientVpnClientCertificateRevocationList is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ExportClientVpnClientCertificateRevocationListInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ExportClientVpnClientCertificateRevocationList(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ExportClientVpnClientCertificateRevocationList_Call {
	return &EC2_ExportClientVpnClientCertificateRevocationList_Call{Call: _e.mock.On("ExportClientVpnClientCertificateRevocationList",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ExportClientVpnClientCertificateRevocationList_Call) Run(run func(ctx context.Context, params *ec2.ExportClientVpnClientCertificateRevocationListInput, optFns ...func(*ec2.Options))) *EC2_ExportClientVpnClientCertificateRevocationList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ExportClientVpnClientCertificateRevocationListInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ExportClientVpnClientCertificateRevocationList_Call) Return(_a0 *ec2.ExportClientVpnClientCertificateRevocationListOutput, _a1 error) *EC2_ExportClientVpnClientCertificateRevocationList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ExportClientVpnClientCertificateRevocationList_Call) RunAndReturn(run func(context.Context, *ec2.ExportClientVpnClientCertificateRevocationListInput, ...func(*ec2.Options)) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error)) *EC2_ExportClientVpnClientCertificateRevocationList_Call {
	_c.Call.Return(run)
	return _c
}

// ExportClientVpnClientConfiguration provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ExportClientVpnClientConfiguration(ctx context.Context, params *ec2.ExportClientVpnClientConfigurationInput, optFns ...func(*ec2.Options)) (*ec2.ExportClientVpnClientConfigurationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ExportClientVpnClientConfiguration")
	}

	var r0 *ec2.ExportClientVpnClientConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportClientVpnClientConfigurationInput, ...func(*ec2.Options)) (*ec2.ExportClientVpnClientConfigurationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportClientVpnClientConfigurationInput, ...func(*ec2.Options)) *ec2.ExportClientVpnClientConfigurationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportClientVpnClientConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportClientVpnClientConfigurationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ExportClientVpnClientConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExportClientVpnClientConfiguration'
type EC2_ExportClientVpnClientConfiguration_Call struct {
	*mock.Call
}

// ExportClientVpnClientConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ExportClientVpnClientConfigurationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ExportClientVpnClientConfiguration(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ExportClientVpnClientConfiguration_Call {
	return &EC2_ExportClientVpnClientConfiguration_Call{Call: _e.mock.On("ExportClientVpnClientConfiguration",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ExportClientVpnClientConfiguration_Call) Run(run func(ctx context.Context, params *ec2.ExportClientVpnClientConfigurationInput, optFns ...func(*ec2.Options))) *EC2_ExportClientVpnClientConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ExportClientVpnClientConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ExportClientVpnClientConfiguration_Call) Return(_a0 *ec2.ExportClientVpnClientConfigurationOutput, _a1 error) *EC2_ExportClientVpnClientConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ExportClientVpnClientConfiguration_Call) RunAndReturn(run func(context.Context, *ec2.ExportClientVpnClientConfigurationInput, ...func(*ec2.Options)) (*ec2.ExportClientVpnClientConfigurationOutput, error)) *EC2_ExportClientVpnClientConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// ExportImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ExportImage(ctx context.Context, params *ec2.ExportImageInput, optFns ...func(*ec2.Options)) (*ec2.ExportImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ExportImage")
	}

	var r0 *ec2.ExportImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportImageInput, ...func(*ec2.Options)) (*ec2.ExportImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportImageInput, ...func(*ec2.Options)) *ec2.ExportImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ExportImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExportImage'
type EC2_ExportImage_Call struct {
	*mock.Call
}

// ExportImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ExportImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ExportImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ExportImage_Call {
	return &EC2_ExportImage_Call{Call: _e.mock.On("ExportImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ExportImage_Call) Run(run func(ctx context.Context, params *ec2.ExportImageInput, optFns ...func(*ec2.Options))) *EC2_ExportImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ExportImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ExportImage_Call) Return(_a0 *ec2.ExportImageOutput, _a1 error) *EC2_ExportImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ExportImage_Call) RunAndReturn(run func(context.Context, *ec2.ExportImageInput, ...func(*ec2.Options)) (*ec2.ExportImageOutput, error)) *EC2_ExportImage_Call {
	_c.Call.Return(run)
	return _c
}

// ExportTransitGatewayRoutes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ExportTransitGatewayRoutes(ctx context.Context, params *ec2.ExportTransitGatewayRoutesInput, optFns ...func(*ec2.Options)) (*ec2.ExportTransitGatewayRoutesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ExportTransitGatewayRoutes")
	}

	var r0 *ec2.ExportTransitGatewayRoutesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportTransitGatewayRoutesInput, ...func(*ec2.Options)) (*ec2.ExportTransitGatewayRoutesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportTransitGatewayRoutesInput, ...func(*ec2.Options)) *ec2.ExportTransitGatewayRoutesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportTransitGatewayRoutesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportTransitGatewayRoutesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ExportTransitGatewayRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExportTransitGatewayRoutes'
type EC2_ExportTransitGatewayRoutes_Call struct {
	*mock.Call
}

// ExportTransitGatewayRoutes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ExportTransitGatewayRoutesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ExportTransitGatewayRoutes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ExportTransitGatewayRoutes_Call {
	return &EC2_ExportTransitGatewayRoutes_Call{Call: _e.mock.On("ExportTransitGatewayRoutes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ExportTransitGatewayRoutes_Call) Run(run func(ctx context.Context, params *ec2.ExportTransitGatewayRoutesInput, optFns ...func(*ec2.Options))) *EC2_ExportTransitGatewayRoutes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ExportTransitGatewayRoutesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ExportTransitGatewayRoutes_Call) Return(_a0 *ec2.ExportTransitGatewayRoutesOutput, _a1 error) *EC2_ExportTransitGatewayRoutes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ExportTransitGatewayRoutes_Call) RunAndReturn(run func(context.Context, *ec2.ExportTransitGatewayRoutesInput, ...func(*ec2.Options)) (*ec2.ExportTransitGatewayRoutesOutput, error)) *EC2_ExportTransitGatewayRoutes_Call {
	_c.Call.Return(run)
	return _c
}

// ExportVerifiedAccessInstanceClientConfiguration provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ExportVerifiedAccessInstanceClientConfiguration(ctx context.Context, params *ec2.ExportVerifiedAccessInstanceClientConfigurationInput, optFns ...func(*ec2.Options)) (*ec2.ExportVerifiedAccessInstanceClientConfigurationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ExportVerifiedAccessInstanceClientConfiguration")
	}

	var r0 *ec2.ExportVerifiedAccessInstanceClientConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportVerifiedAccessInstanceClientConfigurationInput, ...func(*ec2.Options)) (*ec2.ExportVerifiedAccessInstanceClientConfigurationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ExportVerifiedAccessInstanceClientConfigurationInput, ...func(*ec2.Options)) *ec2.ExportVerifiedAccessInstanceClientConfigurationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ExportVerifiedAccessInstanceClientConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ExportVerifiedAccessInstanceClientConfigurationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ExportVerifiedAccessInstanceClientConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExportVerifiedAccessInstanceClientConfiguration'
type EC2_ExportVerifiedAccessInstanceClientConfiguration_Call struct {
	*mock.Call
}

// ExportVerifiedAccessInstanceClientConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ExportVerifiedAccessInstanceClientConfigurationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ExportVerifiedAccessInstanceClientConfiguration(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ExportVerifiedAccessInstanceClientConfiguration_Call {
	return &EC2_ExportVerifiedAccessInstanceClientConfiguration_Call{Call: _e.mock.On("ExportVerifiedAccessInstanceClientConfiguration",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ExportVerifiedAccessInstanceClientConfiguration_Call) Run(run func(ctx context.Context, params *ec2.ExportVerifiedAccessInstanceClientConfigurationInput, optFns ...func(*ec2.Options))) *EC2_ExportVerifiedAccessInstanceClientConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ExportVerifiedAccessInstanceClientConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ExportVerifiedAccessInstanceClientConfiguration_Call) Return(_a0 *ec2.ExportVerifiedAccessInstanceClientConfigurationOutput, _a1 error) *EC2_ExportVerifiedAccessInstanceClientConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ExportVerifiedAccessInstanceClientConfiguration_Call) RunAndReturn(run func(context.Context, *ec2.ExportVerifiedAccessInstanceClientConfigurationInput, ...func(*ec2.Options)) (*ec2.ExportVerifiedAccessInstanceClientConfigurationOutput, error)) *EC2_ExportVerifiedAccessInstanceClientConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// GetActiveVpnTunnelStatus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetActiveVpnTunnelStatus(ctx context.Context, params *ec2.GetActiveVpnTunnelStatusInput, optFns ...func(*ec2.Options)) (*ec2.GetActiveVpnTunnelStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetActiveVpnTunnelStatus")
	}

	var r0 *ec2.GetActiveVpnTunnelStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetActiveVpnTunnelStatusInput, ...func(*ec2.Options)) (*ec2.GetActiveVpnTunnelStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetActiveVpnTunnelStatusInput, ...func(*ec2.Options)) *ec2.GetActiveVpnTunnelStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetActiveVpnTunnelStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetActiveVpnTunnelStatusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetActiveVpnTunnelStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveVpnTunnelStatus'
type EC2_GetActiveVpnTunnelStatus_Call struct {
	*mock.Call
}

// GetActiveVpnTunnelStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetActiveVpnTunnelStatusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetActiveVpnTunnelStatus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetActiveVpnTunnelStatus_Call {
	return &EC2_GetActiveVpnTunnelStatus_Call{Call: _e.mock.On("GetActiveVpnTunnelStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetActiveVpnTunnelStatus_Call) Run(run func(ctx context.Context, params *ec2.GetActiveVpnTunnelStatusInput, optFns ...func(*ec2.Options))) *EC2_GetActiveVpnTunnelStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetActiveVpnTunnelStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetActiveVpnTunnelStatus_Call) Return(_a0 *ec2.GetActiveVpnTunnelStatusOutput, _a1 error) *EC2_GetActiveVpnTunnelStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetActiveVpnTunnelStatus_Call) RunAndReturn(run func(context.Context, *ec2.GetActiveVpnTunnelStatusInput, ...func(*ec2.Options)) (*ec2.GetActiveVpnTunnelStatusOutput, error)) *EC2_GetActiveVpnTunnelStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllowedImagesSettings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetAllowedImagesSettings(ctx context.Context, params *ec2.GetAllowedImagesSettingsInput, optFns ...func(*ec2.Options)) (*ec2.GetAllowedImagesSettingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetAllowedImagesSettings")
	}

	var r0 *ec2.GetAllowedImagesSettingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAllowedImagesSettingsInput, ...func(*ec2.Options)) (*ec2.GetAllowedImagesSettingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAllowedImagesSettingsInput, ...func(*ec2.Options)) *ec2.GetAllowedImagesSettingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetAllowedImagesSettingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetAllowedImagesSettingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetAllowedImagesSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllowedImagesSettings'
type EC2_GetAllowedImagesSettings_Call struct {
	*mock.Call
}

// GetAllowedImagesSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetAllowedImagesSettingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetAllowedImagesSettings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetAllowedImagesSettings_Call {
	return &EC2_GetAllowedImagesSettings_Call{Call: _e.mock.On("GetAllowedImagesSettings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetAllowedImagesSettings_Call) Run(run func(ctx context.Context, params *ec2.GetAllowedImagesSettingsInput, optFns ...func(*ec2.Options))) *EC2_GetAllowedImagesSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetAllowedImagesSettingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetAllowedImagesSettings_Call) Return(_a0 *ec2.GetAllowedImagesSettingsOutput, _a1 error) *EC2_GetAllowedImagesSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetAllowedImagesSettings_Call) RunAndReturn(run func(context.Context, *ec2.GetAllowedImagesSettingsInput, ...func(*ec2.Options)) (*ec2.GetAllowedImagesSettingsOutput, error)) *EC2_GetAllowedImagesSettings_Call {
	_c.Call.Return(run)
	return _c
}

// GetAssociatedEnclaveCertificateIamRoles provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetAssociatedEnclaveCertificateIamRoles(ctx context.Context, params *ec2.GetAssociatedEnclaveCertificateIamRolesInput, optFns ...func(*ec2.Options)) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetAssociatedEnclaveCertificateIamRoles")
	}

	var r0 *ec2.GetAssociatedEnclaveCertificateIamRolesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAssociatedEnclaveCertificateIamRolesInput, ...func(*ec2.Options)) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAssociatedEnclaveCertificateIamRolesInput, ...func(*ec2.Options)) *ec2.GetAssociatedEnclaveCertificateIamRolesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetAssociatedEnclaveCertificateIamRolesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetAssociatedEnclaveCertificateIamRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAssociatedEnclaveCertificateIamRoles'
type EC2_GetAssociatedEnclaveCertificateIamRoles_Call struct {
	*mock.Call
}

// GetAssociatedEnclaveCertificateIamRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetAssociatedEnclaveCertificateIamRolesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetAssociatedEnclaveCertificateIamRoles(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetAssociatedEnclaveCertificateIamRoles_Call {
	return &EC2_GetAssociatedEnclaveCertificateIamRoles_Call{Call: _e.mock.On("GetAssociatedEnclaveCertificateIamRoles",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetAssociatedEnclaveCertificateIamRoles_Call) Run(run func(ctx context.Context, params *ec2.GetAssociatedEnclaveCertificateIamRolesInput, optFns ...func(*ec2.Options))) *EC2_GetAssociatedEnclaveCertificateIamRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetAssociatedEnclaveCertificateIamRolesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetAssociatedEnclaveCertificateIamRoles_Call) Return(_a0 *ec2.GetAssociatedEnclaveCertificateIamRolesOutput, _a1 error) *EC2_GetAssociatedEnclaveCertificateIamRoles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetAssociatedEnclaveCertificateIamRoles_Call) RunAndReturn(run func(context.Context, *ec2.GetAssociatedEnclaveCertificateIamRolesInput, ...func(*ec2.Options)) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error)) *EC2_GetAssociatedEnclaveCertificateIamRoles_Call {
	_c.Call.Return(run)
	return _c
}

// GetAssociatedIpv6PoolCidrs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetAssociatedIpv6PoolCidrs(ctx context.Context, params *ec2.GetAssociatedIpv6PoolCidrsInput, optFns ...func(*ec2.Options)) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetAssociatedIpv6PoolCidrs")
	}

	var r0 *ec2.GetAssociatedIpv6PoolCidrsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAssociatedIpv6PoolCidrsInput, ...func(*ec2.Options)) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAssociatedIpv6PoolCidrsInput, ...func(*ec2.Options)) *ec2.GetAssociatedIpv6PoolCidrsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetAssociatedIpv6PoolCidrsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetAssociatedIpv6PoolCidrsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetAssociatedIpv6PoolCidrs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAssociatedIpv6PoolCidrs'
type EC2_GetAssociatedIpv6PoolCidrs_Call struct {
	*mock.Call
}

// GetAssociatedIpv6PoolCidrs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetAssociatedIpv6PoolCidrsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetAssociatedIpv6PoolCidrs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetAssociatedIpv6PoolCidrs_Call {
	return &EC2_GetAssociatedIpv6PoolCidrs_Call{Call: _e.mock.On("GetAssociatedIpv6PoolCidrs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetAssociatedIpv6PoolCidrs_Call) Run(run func(ctx context.Context, params *ec2.GetAssociatedIpv6PoolCidrsInput, optFns ...func(*ec2.Options))) *EC2_GetAssociatedIpv6PoolCidrs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetAssociatedIpv6PoolCidrsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetAssociatedIpv6PoolCidrs_Call) Return(_a0 *ec2.GetAssociatedIpv6PoolCidrsOutput, _a1 error) *EC2_GetAssociatedIpv6PoolCidrs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetAssociatedIpv6PoolCidrs_Call) RunAndReturn(run func(context.Context, *ec2.GetAssociatedIpv6PoolCidrsInput, ...func(*ec2.Options)) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error)) *EC2_GetAssociatedIpv6PoolCidrs_Call {
	_c.Call.Return(run)
	return _c
}

// GetAwsNetworkPerformanceData provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetAwsNetworkPerformanceData(ctx context.Context, params *ec2.GetAwsNetworkPerformanceDataInput, optFns ...func(*ec2.Options)) (*ec2.GetAwsNetworkPerformanceDataOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetAwsNetworkPerformanceData")
	}

	var r0 *ec2.GetAwsNetworkPerformanceDataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAwsNetworkPerformanceDataInput, ...func(*ec2.Options)) (*ec2.GetAwsNetworkPerformanceDataOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetAwsNetworkPerformanceDataInput, ...func(*ec2.Options)) *ec2.GetAwsNetworkPerformanceDataOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetAwsNetworkPerformanceDataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetAwsNetworkPerformanceDataInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetAwsNetworkPerformanceData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAwsNetworkPerformanceData'
type EC2_GetAwsNetworkPerformanceData_Call struct {
	*mock.Call
}

// GetAwsNetworkPerformanceData is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetAwsNetworkPerformanceDataInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetAwsNetworkPerformanceData(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetAwsNetworkPerformanceData_Call {
	return &EC2_GetAwsNetworkPerformanceData_Call{Call: _e.mock.On("GetAwsNetworkPerformanceData",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetAwsNetworkPerformanceData_Call) Run(run func(ctx context.Context, params *ec2.GetAwsNetworkPerformanceDataInput, optFns ...func(*ec2.Options))) *EC2_GetAwsNetworkPerformanceData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetAwsNetworkPerformanceDataInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetAwsNetworkPerformanceData_Call) Return(_a0 *ec2.GetAwsNetworkPerformanceDataOutput, _a1 error) *EC2_GetAwsNetworkPerformanceData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetAwsNetworkPerformanceData_Call) RunAndReturn(run func(context.Context, *ec2.GetAwsNetworkPerformanceDataInput, ...func(*ec2.Options)) (*ec2.GetAwsNetworkPerformanceDataOutput, error)) *EC2_GetAwsNetworkPerformanceData_Call {
	_c.Call.Return(run)
	return _c
}

// GetCapacityManagerAttributes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetCapacityManagerAttributes(ctx context.Context, params *ec2.GetCapacityManagerAttributesInput, optFns ...func(*ec2.Options)) (*ec2.GetCapacityManagerAttributesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetCapacityManagerAttributes")
	}

	var r0 *ec2.GetCapacityManagerAttributesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityManagerAttributesInput, ...func(*ec2.Options)) (*ec2.GetCapacityManagerAttributesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityManagerAttributesInput, ...func(*ec2.Options)) *ec2.GetCapacityManagerAttributesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCapacityManagerAttributesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetCapacityManagerAttributesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetCapacityManagerAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCapacityManagerAttributes'
type EC2_GetCapacityManagerAttributes_Call struct {
	*mock.Call
}

// GetCapacityManagerAttributes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetCapacityManagerAttributesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetCapacityManagerAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetCapacityManagerAttributes_Call {
	return &EC2_GetCapacityManagerAttributes_Call{Call: _e.mock.On("GetCapacityManagerAttributes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetCapacityManagerAttributes_Call) Run(run func(ctx context.Context, params *ec2.GetCapacityManagerAttributesInput, optFns ...func(*ec2.Options))) *EC2_GetCapacityManagerAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetCapacityManagerAttributesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetCapacityManagerAttributes_Call) Return(_a0 *ec2.GetCapacityManagerAttributesOutput, _a1 error) *EC2_GetCapacityManagerAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetCapacityManagerAttributes_Call) RunAndReturn(run func(context.Context, *ec2.GetCapacityManagerAttributesInput, ...func(*ec2.Options)) (*ec2.GetCapacityManagerAttributesOutput, error)) *EC2_GetCapacityManagerAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// GetCapacityManagerMetricData provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetCapacityManagerMetricData(ctx context.Context, params *ec2.GetCapacityManagerMetricDataInput, optFns ...func(*ec2.Options)) (*ec2.GetCapacityManagerMetricDataOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetCapacityManagerMetricData")
	}

	var r0 *ec2.GetCapacityManagerMetricDataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityManagerMetricDataInput, ...func(*ec2.Options)) (*ec2.GetCapacityManagerMetricDataOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityManagerMetricDataInput, ...func(*ec2.Options)) *ec2.GetCapacityManagerMetricDataOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCapacityManagerMetricDataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetCapacityManagerMetricDataInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetCapacityManagerMetricData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCapacityManagerMetricData'
type EC2_GetCapacityManagerMetricData_Call struct {
	*mock.Call
}

// GetCapacityManagerMetricData is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetCapacityManagerMetricDataInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetCapacityManagerMetricData(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetCapacityManagerMetricData_Call {
	return &EC2_GetCapacityManagerMetricData_Call{Call: _e.mock.On("GetCapacityManagerMetricData",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetCapacityManagerMetricData_Call) Run(run func(ctx context.Context, params *ec2.GetCapacityManagerMetricDataInput, optFns ...func(*ec2.Options))) *EC2_GetCapacityManagerMetricData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetCapacityManagerMetricDataInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetCapacityManagerMetricData_Call) Return(_a0 *ec2.GetCapacityManagerMetricDataOutput, _a1 error) *EC2_GetCapacityManagerMetricData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetCapacityManagerMetricData_Call) RunAndReturn(run func(context.Context, *ec2.GetCapacityManagerMetricDataInput, ...func(*ec2.Options)) (*ec2.GetCapacityManagerMetricDataOutput, error)) *EC2_GetCapacityManagerMetricData_Call {
	_c.Call.Return(run)
	return _c
}

// GetCapacityManagerMetricDimensions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetCapacityManagerMetricDimensions(ctx context.Context, params *ec2.GetCapacityManagerMetricDimensionsInput, optFns ...func(*ec2.Options)) (*ec2.GetCapacityManagerMetricDimensionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetCapacityManagerMetricDimensions")
	}

	var r0 *ec2.GetCapacityManagerMetricDimensionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityManagerMetricDimensionsInput, ...func(*ec2.Options)) (*ec2.GetCapacityManagerMetricDimensionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityManagerMetricDimensionsInput, ...func(*ec2.Options)) *ec2.GetCapacityManagerMetricDimensionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCapacityManagerMetricDimensionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetCapacityManagerMetricDimensionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetCapacityManagerMetricDimensions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCapacityManagerMetricDimensions'
type EC2_GetCapacityManagerMetricDimensions_Call struct {
	*mock.Call
}

// GetCapacityManagerMetricDimensions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetCapacityManagerMetricDimensionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetCapacityManagerMetricDimensions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetCapacityManagerMetricDimensions_Call {
	return &EC2_GetCapacityManagerMetricDimensions_Call{Call: _e.mock.On("GetCapacityManagerMetricDimensions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetCapacityManagerMetricDimensions_Call) Run(run func(ctx context.Context, params *ec2.GetCapacityManagerMetricDimensionsInput, optFns ...func(*ec2.Options))) *EC2_GetCapacityManagerMetricDimensions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetCapacityManagerMetricDimensionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetCapacityManagerMetricDimensions_Call) Return(_a0 *ec2.GetCapacityManagerMetricDimensionsOutput, _a1 error) *EC2_GetCapacityManagerMetricDimensions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetCapacityManagerMetricDimensions_Call) RunAndReturn(run func(context.Context, *ec2.GetCapacityManagerMetricDimensionsInput, ...func(*ec2.Options)) (*ec2.GetCapacityManagerMetricDimensionsOutput, error)) *EC2_GetCapacityManagerMetricDimensions_Call {
	_c.Call.Return(run)
	return _c
}

// GetCapacityReservationUsage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetCapacityReservationUsage(ctx context.Context, params *ec2.GetCapacityReservationUsageInput, optFns ...func(*ec2.Options)) (*ec2.GetCapacityReservationUsageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetCapacityReservationUsage")
	}

	var r0 *ec2.GetCapacityReservationUsageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityReservationUsageInput, ...func(*ec2.Options)) (*ec2.GetCapacityReservationUsageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCapacityReservationUsageInput, ...func(*ec2.Options)) *ec2.GetCapacityReservationUsageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCapacityReservationUsageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetCapacityReservationUsageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetCapacityReservationUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCapacityReservationUsage'
type EC2_GetCapacityReservationUsage_Call struct {
	*mock.Call
}

// GetCapacityReservationUsage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetCapacityReservationUsageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetCapacityReservationUsage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetCapacityReservationUsage_Call {
	return &EC2_GetCapacityReservationUsage_Call{Call: _e.mock.On("GetCapacityReservationUsage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetCapacityReservationUsage_Call) Run(run func(ctx context.Context, params *ec2.GetCapacityReservationUsageInput, optFns ...func(*ec2.Options))) *EC2_GetCapacityReservationUsage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetCapacityReservationUsageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetCapacityReservationUsage_Call) Return(_a0 *ec2.GetCapacityReservationUsageOutput, _a1 error) *EC2_GetCapacityReservationUsage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetCapacityReservationUsage_Call) RunAndReturn(run func(context.Context, *ec2.GetCapacityReservationUsageInput, ...func(*ec2.Options)) (*ec2.GetCapacityReservationUsageOutput, error)) *EC2_GetCapacityReservationUsage_Call {
	_c.Call.Return(run)
	return _c
}

// GetCoipPoolUsage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetCoipPoolUsage(ctx context.Context, params *ec2.GetCoipPoolUsageInput, optFns ...func(*ec2.Options)) (*ec2.GetCoipPoolUsageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetCoipPoolUsage")
	}

	var r0 *ec2.GetCoipPoolUsageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCoipPoolUsageInput, ...func(*ec2.Options)) (*ec2.GetCoipPoolUsageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetCoipPoolUsageInput, ...func(*ec2.Options)) *ec2.GetCoipPoolUsageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetCoipPoolUsageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetCoipPoolUsageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetCoipPoolUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCoipPoolUsage'
type EC2_GetCoipPoolUsage_Call struct {
	*mock.Call
}

// GetCoipPoolUsage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetCoipPoolUsageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetCoipPoolUsage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetCoipPoolUsage_Call {
	return &EC2_GetCoipPoolUsage_Call{Call: _e.mock.On("GetCoipPoolUsage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetCoipPoolUsage_Call) Run(run func(ctx context.Context, params *ec2.GetCoipPoolUsageInput, optFns ...func(*ec2.Options))) *EC2_GetCoipPoolUsage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetCoipPoolUsageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetCoipPoolUsage_Call) Return(_a0 *ec2.GetCoipPoolUsageOutput, _a1 error) *EC2_GetCoipPoolUsage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetCoipPoolUsage_Call) RunAndReturn(run func(context.Context, *ec2.GetCoipPoolUsageInput, ...func(*ec2.Options)) (*ec2.GetCoipPoolUsageOutput, error)) *EC2_GetCoipPoolUsage_Call {
	_c.Call.Return(run)
	return _c
}

// GetConsoleOutput provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetConsoleOutput(ctx context.Context, params *ec2.GetConsoleOutputInput, optFns ...func(*ec2.Options)) (*ec2.GetConsoleOutputOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetConsoleOutput")
	}

	var r0 *ec2.GetConsoleOutputOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetConsoleOutputInput, ...func(*ec2.Options)) (*ec2.GetConsoleOutputOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetConsoleOutputInput, ...func(*ec2.Options)) *ec2.GetConsoleOutputOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetConsoleOutputOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetConsoleOutputInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetConsoleOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConsoleOutput'
type EC2_GetConsoleOutput_Call struct {
	*mock.Call
}

// GetConsoleOutput is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetConsoleOutputInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetConsoleOutput(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetConsoleOutput_Call {
	return &EC2_GetConsoleOutput_Call{Call: _e.mock.On("GetConsoleOutput",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetConsoleOutput_Call) Run(run func(ctx context.Context, params *ec2.GetConsoleOutputInput, optFns ...func(*ec2.Options))) *EC2_GetConsoleOutput_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetConsoleOutputInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetConsoleOutput_Call) Return(_a0 *ec2.GetConsoleOutputOutput, _a1 error) *EC2_GetConsoleOutput_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetConsoleOutput_Call) RunAndReturn(run func(context.Context, *ec2.GetConsoleOutputInput, ...func(*ec2.Options)) (*ec2.GetConsoleOutputOutput, error)) *EC2_GetConsoleOutput_Call {
	_c.Call.Return(run)
	return _c
}

// GetConsoleScreenshot provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetConsoleScreenshot(ctx context.Context, params *ec2.GetConsoleScreenshotInput, optFns ...func(*ec2.Options)) (*ec2.GetConsoleScreenshotOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetConsoleScreenshot")
	}

	var r0 *ec2.GetConsoleScreenshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetConsoleScreenshotInput, ...func(*ec2.Options)) (*ec2.GetConsoleScreenshotOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetConsoleScreenshotInput, ...func(*ec2.Options)) *ec2.GetConsoleScreenshotOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetConsoleScreenshotOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetConsoleScreenshotInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetConsoleScreenshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConsoleScreenshot'
type EC2_GetConsoleScreenshot_Call struct {
	*mock.Call
}

// GetConsoleScreenshot is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetConsoleScreenshotInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetConsoleScreenshot(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetConsoleScreenshot_Call {
	return &EC2_GetConsoleScreenshot_Call{Call: _e.mock.On("GetConsoleScreenshot",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetConsoleScreenshot_Call) Run(run func(ctx context.Context, params *ec2.GetConsoleScreenshotInput, optFns ...func(*ec2.Options))) *EC2_GetConsoleScreenshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetConsoleScreenshotInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetConsoleScreenshot_Call) Return(_a0 *ec2.GetConsoleScreenshotOutput, _a1 error) *EC2_GetConsoleScreenshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetConsoleScreenshot_Call) RunAndReturn(run func(context.Context, *ec2.GetConsoleScreenshotInput, ...func(*ec2.Options)) (*ec2.GetConsoleScreenshotOutput, error)) *EC2_GetConsoleScreenshot_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeclarativePoliciesReportSummary provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetDeclarativePoliciesReportSummary(ctx context.Context, params *ec2.GetDeclarativePoliciesReportSummaryInput, optFns ...func(*ec2.Options)) (*ec2.GetDeclarativePoliciesReportSummaryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetDeclarativePoliciesReportSummary")
	}

	var r0 *ec2.GetDeclarativePoliciesReportSummaryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetDeclarativePoliciesReportSummaryInput, ...func(*ec2.Options)) (*ec2.GetDeclarativePoliciesReportSummaryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetDeclarativePoliciesReportSummaryInput, ...func(*ec2.Options)) *ec2.GetDeclarativePoliciesReportSummaryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetDeclarativePoliciesReportSummaryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetDeclarativePoliciesReportSummaryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetDeclarativePoliciesReportSummary_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeclarativePoliciesReportSummary'
type EC2_GetDeclarativePoliciesReportSummary_Call struct {
	*mock.Call
}

// GetDeclarativePoliciesReportSummary is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetDeclarativePoliciesReportSummaryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetDeclarativePoliciesReportSummary(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetDeclarativePoliciesReportSummary_Call {
	return &EC2_GetDeclarativePoliciesReportSummary_Call{Call: _e.mock.On("GetDeclarativePoliciesReportSummary",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetDeclarativePoliciesReportSummary_Call) Run(run func(ctx context.Context, params *ec2.GetDeclarativePoliciesReportSummaryInput, optFns ...func(*ec2.Options))) *EC2_GetDeclarativePoliciesReportSummary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetDeclarativePoliciesReportSummaryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetDeclarativePoliciesReportSummary_Call) Return(_a0 *ec2.GetDeclarativePoliciesReportSummaryOutput, _a1 error) *EC2_GetDeclarativePoliciesReportSummary_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetDeclarativePoliciesReportSummary_Call) RunAndReturn(run func(context.Context, *ec2.GetDeclarativePoliciesReportSummaryInput, ...func(*ec2.Options)) (*ec2.GetDeclarativePoliciesReportSummaryOutput, error)) *EC2_GetDeclarativePoliciesReportSummary_Call {
	_c.Call.Return(run)
	return _c
}

// GetDefaultCreditSpecification provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetDefaultCreditSpecification(ctx context.Context, params *ec2.GetDefaultCreditSpecificationInput, optFns ...func(*ec2.Options)) (*ec2.GetDefaultCreditSpecificationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetDefaultCreditSpecification")
	}

	var r0 *ec2.GetDefaultCreditSpecificationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetDefaultCreditSpecificationInput, ...func(*ec2.Options)) (*ec2.GetDefaultCreditSpecificationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetDefaultCreditSpecificationInput, ...func(*ec2.Options)) *ec2.GetDefaultCreditSpecificationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetDefaultCreditSpecificationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetDefaultCreditSpecificationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetDefaultCreditSpecification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultCreditSpecification'
type EC2_GetDefaultCreditSpecification_Call struct {
	*mock.Call
}

// GetDefaultCreditSpecification is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetDefaultCreditSpecificationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetDefaultCreditSpecification(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetDefaultCreditSpecification_Call {
	return &EC2_GetDefaultCreditSpecification_Call{Call: _e.mock.On("GetDefaultCreditSpecification",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetDefaultCreditSpecification_Call) Run(run func(ctx context.Context, params *ec2.GetDefaultCreditSpecificationInput, optFns ...func(*ec2.Options))) *EC2_GetDefaultCreditSpecification_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetDefaultCreditSpecificationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetDefaultCreditSpecification_Call) Return(_a0 *ec2.GetDefaultCreditSpecificationOutput, _a1 error) *EC2_GetDefaultCreditSpecification_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetDefaultCreditSpecification_Call) RunAndReturn(run func(context.Context, *ec2.GetDefaultCreditSpecificationInput, ...func(*ec2.Options)) (*ec2.GetDefaultCreditSpecificationOutput, error)) *EC2_GetDefaultCreditSpecification_Call {
	_c.Call.Return(run)
	return _c
}

// GetEbsDefaultKmsKeyId provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetEbsDefaultKmsKeyId(ctx context.Context, params *ec2.GetEbsDefaultKmsKeyIdInput, optFns ...func(*ec2.Options)) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetEbsDefaultKmsKeyId")
	}

	var r0 *ec2.GetEbsDefaultKmsKeyIdOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) (*ec2.GetEbsDefaultKmsKeyIdOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) *ec2.GetEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetEbsDefaultKmsKeyIdOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetEbsDefaultKmsKeyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEbsDefaultKmsKeyId'
type EC2_GetEbsDefaultKmsKeyId_Call struct {
	*mock.Call
}

// GetEbsDefaultKmsKeyId is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetEbsDefaultKmsKeyIdInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetEbsDefaultKmsKeyId(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetEbsDefaultKmsKeyId_Call {
	return &EC2_GetEbsDefaultKmsKeyId_Call{Call: _e.mock.On("GetEbsDefaultKmsKeyId",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetEbsDefaultKmsKeyId_Call) Run(run func(ctx context.Context, params *ec2.GetEbsDefaultKmsKeyIdInput, optFns ...func(*ec2.Options))) *EC2_GetEbsDefaultKmsKeyId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetEbsDefaultKmsKeyIdInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetEbsDefaultKmsKeyId_Call) Return(_a0 *ec2.GetEbsDefaultKmsKeyIdOutput, _a1 error) *EC2_GetEbsDefaultKmsKeyId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetEbsDefaultKmsKeyId_Call) RunAndReturn(run func(context.Context, *ec2.GetEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) (*ec2.GetEbsDefaultKmsKeyIdOutput, error)) *EC2_GetEbsDefaultKmsKeyId_Call {
	_c.Call.Return(run)
	return _c
}

// GetEbsEncryptionByDefault provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetEbsEncryptionByDefault(ctx context.Context, params *ec2.GetEbsEncryptionByDefaultInput, optFns ...func(*ec2.Options)) (*ec2.GetEbsEncryptionByDefaultOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetEbsEncryptionByDefault")
	}

	var r0 *ec2.GetEbsEncryptionByDefaultOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEbsEncryptionByDefaultInput, ...func(*ec2.Options)) (*ec2.GetEbsEncryptionByDefaultOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEbsEncryptionByDefaultInput, ...func(*ec2.Options)) *ec2.GetEbsEncryptionByDefaultOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetEbsEncryptionByDefaultOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetEbsEncryptionByDefaultInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetEbsEncryptionByDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEbsEncryptionByDefault'
type EC2_GetEbsEncryptionByDefault_Call struct {
	*mock.Call
}

// GetEbsEncryptionByDefault is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetEbsEncryptionByDefaultInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetEbsEncryptionByDefault(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetEbsEncryptionByDefault_Call {
	return &EC2_GetEbsEncryptionByDefault_Call{Call: _e.mock.On("GetEbsEncryptionByDefault",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetEbsEncryptionByDefault_Call) Run(run func(ctx context.Context, params *ec2.GetEbsEncryptionByDefaultInput, optFns ...func(*ec2.Options))) *EC2_GetEbsEncryptionByDefault_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetEbsEncryptionByDefaultInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetEbsEncryptionByDefault_Call) Return(_a0 *ec2.GetEbsEncryptionByDefaultOutput, _a1 error) *EC2_GetEbsEncryptionByDefault_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetEbsEncryptionByDefault_Call) RunAndReturn(run func(context.Context, *ec2.GetEbsEncryptionByDefaultInput, ...func(*ec2.Options)) (*ec2.GetEbsEncryptionByDefaultOutput, error)) *EC2_GetEbsEncryptionByDefault_Call {
	_c.Call.Return(run)
	return _c
}

// GetEnabledIpamPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetEnabledIpamPolicy(ctx context.Context, params *ec2.GetEnabledIpamPolicyInput, optFns ...func(*ec2.Options)) (*ec2.GetEnabledIpamPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetEnabledIpamPolicy")
	}

	var r0 *ec2.GetEnabledIpamPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEnabledIpamPolicyInput, ...func(*ec2.Options)) (*ec2.GetEnabledIpamPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetEnabledIpamPolicyInput, ...func(*ec2.Options)) *ec2.GetEnabledIpamPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetEnabledIpamPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetEnabledIpamPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetEnabledIpamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnabledIpamPolicy'
type EC2_GetEnabledIpamPolicy_Call struct {
	*mock.Call
}

// GetEnabledIpamPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetEnabledIpamPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetEnabledIpamPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetEnabledIpamPolicy_Call {
	return &EC2_GetEnabledIpamPolicy_Call{Call: _e.mock.On("GetEnabledIpamPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetEnabledIpamPolicy_Call) Run(run func(ctx context.Context, params *ec2.GetEnabledIpamPolicyInput, optFns ...func(*ec2.Options))) *EC2_GetEnabledIpamPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetEnabledIpamPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetEnabledIpamPolicy_Call) Return(_a0 *ec2.GetEnabledIpamPolicyOutput, _a1 error) *EC2_GetEnabledIpamPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetEnabledIpamPolicy_Call) RunAndReturn(run func(context.Context, *ec2.GetEnabledIpamPolicyInput, ...func(*ec2.Options)) (*ec2.GetEnabledIpamPolicyOutput, error)) *EC2_GetEnabledIpamPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetFlowLogsIntegrationTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetFlowLogsIntegrationTemplate(ctx context.Context, params *ec2.GetFlowLogsIntegrationTemplateInput, optFns ...func(*ec2.Options)) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetFlowLogsIntegrationTemplate")
	}

	var r0 *ec2.GetFlowLogsIntegrationTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetFlowLogsIntegrationTemplateInput, ...func(*ec2.Options)) (*ec2.GetFlowLogsIntegrationTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetFlowLogsIntegrationTemplateInput, ...func(*ec2.Options)) *ec2.GetFlowLogsIntegrationTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetFlowLogsIntegrationTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetFlowLogsIntegrationTemplateInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetFlowLogsIntegrationTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlowLogsIntegrationTemplate'
type EC2_GetFlowLogsIntegrationTemplate_Call struct {
	*mock.Call
}

// GetFlowLogsIntegrationTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetFlowLogsIntegrationTemplateInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetFlowLogsIntegrationTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetFlowLogsIntegrationTemplate_Call {
	return &EC2_GetFlowLogsIntegrationTemplate_Call{Call: _e.mock.On("GetFlowLogsIntegrationTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetFlowLogsIntegrationTemplate_Call) Run(run func(ctx context.Context, params *ec2.GetFlowLogsIntegrationTemplateInput, optFns ...func(*ec2.Options))) *EC2_GetFlowLogsIntegrationTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetFlowLogsIntegrationTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetFlowLogsIntegrationTemplate_Call) Return(_a0 *ec2.GetFlowLogsIntegrationTemplateOutput, _a1 error) *EC2_GetFlowLogsIntegrationTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetFlowLogsIntegrationTemplate_Call) RunAndReturn(run func(context.Context, *ec2.GetFlowLogsIntegrationTemplateInput, ...func(*ec2.Options)) (*ec2.GetFlowLogsIntegrationTemplateOutput, error)) *EC2_GetFlowLogsIntegrationTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetGroupsForCapacityReservation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetGroupsForCapacityReservation(ctx context.Context, params *ec2.GetGroupsForCapacityReservationInput, optFns ...func(*ec2.Options)) (*ec2.GetGroupsForCapacityReservationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetGroupsForCapacityReservation")
	}

	var r0 *ec2.GetGroupsForCapacityReservationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetGroupsForCapacityReservationInput, ...func(*ec2.Options)) (*ec2.GetGroupsForCapacityReservationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetGroupsForCapacityReservationInput, ...func(*ec2.Options)) *ec2.GetGroupsForCapacityReservationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetGroupsForCapacityReservationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetGroupsForCapacityReservationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetGroupsForCapacityReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGroupsForCapacityReservation'
type EC2_GetGroupsForCapacityReservation_Call struct {
	*mock.Call
}

// GetGroupsForCapacityReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetGroupsForCapacityReservationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetGroupsForCapacityReservation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetGroupsForCapacityReservation_Call {
	return &EC2_GetGroupsForCapacityReservation_Call{Call: _e.mock.On("GetGroupsForCapacityReservation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetGroupsForCapacityReservation_Call) Run(run func(ctx context.Context, params *ec2.GetGroupsForCapacityReservationInput, optFns ...func(*ec2.Options))) *EC2_GetGroupsForCapacityReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetGroupsForCapacityReservationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetGroupsForCapacityReservation_Call) Return(_a0 *ec2.GetGroupsForCapacityReservationOutput, _a1 error) *EC2_GetGroupsForCapacityReservation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetGroupsForCapacityReservation_Call) RunAndReturn(run func(context.Context, *ec2.GetGroupsForCapacityReservationInput, ...func(*ec2.Options)) (*ec2.GetGroupsForCapacityReservationOutput, error)) *EC2_GetGroupsForCapacityReservation_Call {
	_c.Call.Return(run)
	return _c
}

// GetHostReservationPurchasePreview provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetHostReservationPurchasePreview(ctx context.Context, params *ec2.GetHostReservationPurchasePreviewInput, optFns ...func(*ec2.Options)) (*ec2.GetHostReservationPurchasePreviewOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetHostReservationPurchasePreview")
	}

	var r0 *ec2.GetHostReservationPurchasePreviewOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetHostReservationPurchasePreviewInput, ...func(*ec2.Options)) (*ec2.GetHostReservationPurchasePreviewOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetHostReservationPurchasePreviewInput, ...func(*ec2.Options)) *ec2.GetHostReservationPurchasePreviewOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetHostReservationPurchasePreviewOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetHostReservationPurchasePreviewInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetHostReservationPurchasePreview_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHostReservationPurchasePreview'
type EC2_GetHostReservationPurchasePreview_Call struct {
	*mock.Call
}

// GetHostReservationPurchasePreview is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetHostReservationPurchasePreviewInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetHostReservationPurchasePreview(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetHostReservationPurchasePreview_Call {
	return &EC2_GetHostReservationPurchasePreview_Call{Call: _e.mock.On("GetHostReservationPurchasePreview",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetHostReservationPurchasePreview_Call) Run(run func(ctx context.Context, params *ec2.GetHostReservationPurchasePreviewInput, optFns ...func(*ec2.Options))) *EC2_GetHostReservationPurchasePreview_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetHostReservationPurchasePreviewInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetHostReservationPurchasePreview_Call) Return(_a0 *ec2.GetHostReservationPurchasePreviewOutput, _a1 error) *EC2_GetHostReservationPurchasePreview_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetHostReservationPurchasePreview_Call) RunAndReturn(run func(context.Context, *ec2.GetHostReservationPurchasePreviewInput, ...func(*ec2.Options)) (*ec2.GetHostReservationPurchasePreviewOutput, error)) *EC2_GetHostReservationPurchasePreview_Call {
	_c.Call.Return(run)
	return _c
}

// GetImageAncestry provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetImageAncestry(ctx context.Context, params *ec2.GetImageAncestryInput, optFns ...func(*ec2.Options)) (*ec2.GetImageAncestryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetImageAncestry")
	}

	var r0 *ec2.GetImageAncestryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetImageAncestryInput, ...func(*ec2.Options)) (*ec2.GetImageAncestryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetImageAncestryInput, ...func(*ec2.Options)) *ec2.GetImageAncestryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetImageAncestryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetImageAncestryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetImageAncestry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImageAncestry'
type EC2_GetImageAncestry_Call struct {
	*mock.Call
}

// GetImageAncestry is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetImageAncestryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetImageAncestry(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetImageAncestry_Call {
	return &EC2_GetImageAncestry_Call{Call: _e.mock.On("GetImageAncestry",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetImageAncestry_Call) Run(run func(ctx context.Context, params *ec2.GetImageAncestryInput, optFns ...func(*ec2.Options))) *EC2_GetImageAncestry_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetImageAncestryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetImageAncestry_Call) Return(_a0 *ec2.GetImageAncestryOutput, _a1 error) *EC2_GetImageAncestry_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetImageAncestry_Call) RunAndReturn(run func(context.Context, *ec2.GetImageAncestryInput, ...func(*ec2.Options)) (*ec2.GetImageAncestryOutput, error)) *EC2_GetImageAncestry_Call {
	_c.Call.Return(run)
	return _c
}

// GetImageBlockPublicAccessState provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetImageBlockPublicAccessState(ctx context.Context, params *ec2.GetImageBlockPublicAccessStateInput, optFns ...func(*ec2.Options)) (*ec2.GetImageBlockPublicAccessStateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetImageBlockPublicAccessState")
	}

	var r0 *ec2.GetImageBlockPublicAccessStateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetImageBlockPublicAccessStateInput, ...func(*ec2.Options)) (*ec2.GetImageBlockPublicAccessStateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetImageBlockPublicAccessStateInput, ...func(*ec2.Options)) *ec2.GetImageBlockPublicAccessStateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetImageBlockPublicAccessStateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetImageBlockPublicAccessStateInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetImageBlockPublicAccessState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImageBlockPublicAccessState'
type EC2_GetImageBlockPublicAccessState_Call struct {
	*mock.Call
}

// GetImageBlockPublicAccessState is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetImageBlockPublicAccessStateInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetImageBlockPublicAccessState(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetImageBlockPublicAccessState_Call {
	return &EC2_GetImageBlockPublicAccessState_Call{Call: _e.mock.On("GetImageBlockPublicAccessState",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetImageBlockPublicAccessState_Call) Run(run func(ctx context.Context, params *ec2.GetImageBlockPublicAccessStateInput, optFns ...func(*ec2.Options))) *EC2_GetImageBlockPublicAccessState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetImageBlockPublicAccessStateInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetImageBlockPublicAccessState_Call) Return(_a0 *ec2.GetImageBlockPublicAccessStateOutput, _a1 error) *EC2_GetImageBlockPublicAccessState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetImageBlockPublicAccessState_Call) RunAndReturn(run func(context.Context, *ec2.GetImageBlockPublicAccessStateInput, ...func(*ec2.Options)) (*ec2.GetImageBlockPublicAccessStateOutput, error)) *EC2_GetImageBlockPublicAccessState_Call {
	_c.Call.Return(run)
	return _c
}

// GetInstanceMetadataDefaults provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetInstanceMetadataDefaults(ctx context.Context, params *ec2.GetInstanceMetadataDefaultsInput, optFns ...func(*ec2.Options)) (*ec2.GetInstanceMetadataDefaultsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetInstanceMetadataDefaults")
	}

	var r0 *ec2.GetInstanceMetadataDefaultsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetInstanceMetadataDefaultsInput, ...func(*ec2.Options)) (*ec2.GetInstanceMetadataDefaultsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetInstanceMetadataDefaultsInput, ...func(*ec2.Options)) *ec2.GetInstanceMetadataDefaultsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetInstanceMetadataDefaultsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetInstanceMetadataDefaultsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetInstanceMetadataDefaults_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstanceMetadataDefaults'
type EC2_GetInstanceMetadataDefaults_Call struct {
	*mock.Call
}

// GetInstanceMetadataDefaults is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetInstanceMetadataDefaultsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetInstanceMetadataDefaults(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetInstanceMetadataDefaults_Call {
	return &EC2_GetInstanceMetadataDefaults_Call{Call: _e.mock.On("GetInstanceMetadataDefaults",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetInstanceMetadataDefaults_Call) Run(run func(ctx context.Context, params *ec2.GetInstanceMetadataDefaultsInput, optFns ...func(*ec2.Options))) *EC2_GetInstanceMetadataDefaults_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetInstanceMetadataDefaultsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetInstanceMetadataDefaults_Call) Return(_a0 *ec2.GetInstanceMetadataDefaultsOutput, _a1 error) *EC2_GetInstanceMetadataDefaults_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetInstanceMetadataDefaults_Call) RunAndReturn(run func(context.Context, *ec2.GetInstanceMetadataDefaultsInput, ...func(*ec2.Options)) (*ec2.GetInstanceMetadataDefaultsOutput, error)) *EC2_GetInstanceMetadataDefaults_Call {
	_c.Call.Return(run)
	return _c
}

// GetInstanceTpmEkPub provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetInstanceTpmEkPub(ctx context.Context, params *ec2.GetInstanceTpmEkPubInput, optFns ...func(*ec2.Options)) (*ec2.GetInstanceTpmEkPubOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetInstanceTpmEkPub")
	}

	var r0 *ec2.GetInstanceTpmEkPubOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetInstanceTpmEkPubInput, ...func(*ec2.Options)) (*ec2.GetInstanceTpmEkPubOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetInstanceTpmEkPubInput, ...func(*ec2.Options)) *ec2.GetInstanceTpmEkPubOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetInstanceTpmEkPubOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetInstanceTpmEkPubInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetInstanceTpmEkPub_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstanceTpmEkPub'
type EC2_GetInstanceTpmEkPub_Call struct {
	*mock.Call
}

// GetInstanceTpmEkPub is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetInstanceTpmEkPubInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetInstanceTpmEkPub(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetInstanceTpmEkPub_Call {
	return &EC2_GetInstanceTpmEkPub_Call{Call: _e.mock.On("GetInstanceTpmEkPub",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetInstanceTpmEkPub_Call) Run(run func(ctx context.Context, params *ec2.GetInstanceTpmEkPubInput, optFns ...func(*ec2.Options))) *EC2_GetInstanceTpmEkPub_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetInstanceTpmEkPubInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetInstanceTpmEkPub_Call) Return(_a0 *ec2.GetInstanceTpmEkPubOutput, _a1 error) *EC2_GetInstanceTpmEkPub_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetInstanceTpmEkPub_Call) RunAndReturn(run func(context.Context, *ec2.GetInstanceTpmEkPubInput, ...func(*ec2.Options)) (*ec2.GetInstanceTpmEkPubOutput, error)) *EC2_GetInstanceTpmEkPub_Call {
	_c.Call.Return(run)
	return _c
}

// GetInstanceTypesFromInstanceRequirements provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetInstanceTypesFromInstanceRequirements(ctx context.Context, params *ec2.GetInstanceTypesFromInstanceRequirementsInput, optFns ...func(*ec2.Options)) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetInstanceTypesFromInstanceRequirements")
	}

	var r0 *ec2.GetInstanceTypesFromInstanceRequirementsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetInstanceTypesFromInstanceRequirementsInput, ...func(*ec2.Options)) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetInstanceTypesFromInstanceRequirementsInput, ...func(*ec2.Options)) *ec2.GetInstanceTypesFromInstanceRequirementsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetInstanceTypesFromInstanceRequirementsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetInstanceTypesFromInstanceRequirementsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetInstanceTypesFromInstanceRequirements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstanceTypesFromInstanceRequirements'
type EC2_GetInstanceTypesFromInstanceRequirements_Call struct {
	*mock.Call
}

// GetInstanceTypesFromInstanceRequirements is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetInstanceTypesFromInstanceRequirementsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetInstanceTypesFromInstanceRequirements(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetInstanceTypesFromInstanceRequirements_Call {
	return &EC2_GetInstanceTypesFromInstanceRequirements_Call{Call: _e.mock.On("GetInstanceTypesFromInstanceRequirements",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetInstanceTypesFromInstanceRequirements_Call) Run(run func(ctx context.Context, params *ec2.GetInstanceTypesFromInstanceRequirementsInput, optFns ...func(*ec2.Options))) *EC2_GetInstanceTypesFromInstanceRequirements_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetInstanceTypesFromInstanceRequirementsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetInstanceTypesFromInstanceRequirements_Call) Return(_a0 *ec2.GetInstanceTypesFromInstanceRequirementsOutput, _a1 error) *EC2_GetInstanceTypesFromInstanceRequirements_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetInstanceTypesFromInstanceRequirements_Call) RunAndReturn(run func(context.Context, *ec2.GetInstanceTypesFromInstanceRequirementsInput, ...func(*ec2.Options)) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error)) *EC2_GetInstanceTypesFromInstanceRequirements_Call {
	_c.Call.Return(run)
	return _c
}

// GetInstanceUefiData provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetInstanceUefiData(ctx context.Context, params *ec2.GetInstanceUefiDataInput, optFns ...func(*ec2.Options)) (*ec2.GetInstanceUefiDataOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetInstanceUefiData")
	}

	var r0 *ec2.GetInstanceUefiDataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetInstanceUefiDataInput, ...func(*ec2.Options)) (*ec2.GetInstanceUefiDataOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetInstanceUefiDataInput, ...func(*ec2.Options)) *ec2.GetInstanceUefiDataOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetInstanceUefiDataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetInstanceUefiDataInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetInstanceUefiData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstanceUefiData'
type EC2_GetInstanceUefiData_Call struct {
	*mock.Call
}

// GetInstanceUefiData is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetInstanceUefiDataInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetInstanceUefiData(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetInstanceUefiData_Call {
	return &EC2_GetInstanceUefiData_Call{Call: _e.mock.On("GetInstanceUefiData",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetInstanceUefiData_Call) Run(run func(ctx context.Context, params *ec2.GetInstanceUefiDataInput, optFns ...func(*ec2.Options))) *EC2_GetInstanceUefiData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetInstanceUefiDataInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetInstanceUefiData_Call) Return(_a0 *ec2.GetInstanceUefiDataOutput, _a1 error) *EC2_GetInstanceUefiData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetInstanceUefiData_Call) RunAndReturn(run func(context.Context, *ec2.GetInstanceUefiDataInput, ...func(*ec2.Options)) (*ec2.GetInstanceUefiDataOutput, error)) *EC2_GetInstanceUefiData_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamAddressHistory provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamAddressHistory(ctx context.Context, params *ec2.GetIpamAddressHistoryInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamAddressHistoryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamAddressHistory")
	}

	var r0 *ec2.GetIpamAddressHistoryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamAddressHistoryInput, ...func(*ec2.Options)) (*ec2.GetIpamAddressHistoryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamAddressHistoryInput, ...func(*ec2.Options)) *ec2.GetIpamAddressHistoryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamAddressHistoryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamAddressHistoryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamAddressHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamAddressHistory'
type EC2_GetIpamAddressHistory_Call struct {
	*mock.Call
}

// GetIpamAddressHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamAddressHistoryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamAddressHistory(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamAddressHistory_Call {
	return &EC2_GetIpamAddressHistory_Call{Call: _e.mock.On("GetIpamAddressHistory",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamAddressHistory_Call) Run(run func(ctx context.Context, params *ec2.GetIpamAddressHistoryInput, optFns ...func(*ec2.Options))) *EC2_GetIpamAddressHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamAddressHistoryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamAddressHistory_Call) Return(_a0 *ec2.GetIpamAddressHistoryOutput, _a1 error) *EC2_GetIpamAddressHistory_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamAddressHistory_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamAddressHistoryInput, ...func(*ec2.Options)) (*ec2.GetIpamAddressHistoryOutput, error)) *EC2_GetIpamAddressHistory_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamDiscoveredAccounts provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamDiscoveredAccounts(ctx context.Context, params *ec2.GetIpamDiscoveredAccountsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredAccountsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamDiscoveredAccounts")
	}

	var r0 *ec2.GetIpamDiscoveredAccountsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamDiscoveredAccountsInput, ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredAccountsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamDiscoveredAccountsInput, ...func(*ec2.Options)) *ec2.GetIpamDiscoveredAccountsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamDiscoveredAccountsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamDiscoveredAccountsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamDiscoveredAccounts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamDiscoveredAccounts'
type EC2_GetIpamDiscoveredAccounts_Call struct {
	*mock.Call
}

// GetIpamDiscoveredAccounts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamDiscoveredAccountsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamDiscoveredAccounts(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamDiscoveredAccounts_Call {
	return &EC2_GetIpamDiscoveredAccounts_Call{Call: _e.mock.On("GetIpamDiscoveredAccounts",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamDiscoveredAccounts_Call) Run(run func(ctx context.Context, params *ec2.GetIpamDiscoveredAccountsInput, optFns ...func(*ec2.Options))) *EC2_GetIpamDiscoveredAccounts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamDiscoveredAccountsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamDiscoveredAccounts_Call) Return(_a0 *ec2.GetIpamDiscoveredAccountsOutput, _a1 error) *EC2_GetIpamDiscoveredAccounts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamDiscoveredAccounts_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamDiscoveredAccountsInput, ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredAccountsOutput, error)) *EC2_GetIpamDiscoveredAccounts_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamDiscoveredPublicAddresses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamDiscoveredPublicAddresses(ctx context.Context, params *ec2.GetIpamDiscoveredPublicAddressesInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamDiscoveredPublicAddresses")
	}

	var r0 *ec2.GetIpamDiscoveredPublicAddressesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamDiscoveredPublicAddressesInput, ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamDiscoveredPublicAddressesInput, ...func(*ec2.Options)) *ec2.GetIpamDiscoveredPublicAddressesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamDiscoveredPublicAddressesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamDiscoveredPublicAddressesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamDiscoveredPublicAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamDiscoveredPublicAddresses'
type EC2_GetIpamDiscoveredPublicAddresses_Call struct {
	*mock.Call
}

// GetIpamDiscoveredPublicAddresses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamDiscoveredPublicAddressesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamDiscoveredPublicAddresses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamDiscoveredPublicAddresses_Call {
	return &EC2_GetIpamDiscoveredPublicAddresses_Call{Call: _e.mock.On("GetIpamDiscoveredPublicAddresses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamDiscoveredPublicAddresses_Call) Run(run func(ctx context.Context, params *ec2.GetIpamDiscoveredPublicAddressesInput, optFns ...func(*ec2.Options))) *EC2_GetIpamDiscoveredPublicAddresses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamDiscoveredPublicAddressesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamDiscoveredPublicAddresses_Call) Return(_a0 *ec2.GetIpamDiscoveredPublicAddressesOutput, _a1 error) *EC2_GetIpamDiscoveredPublicAddresses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamDiscoveredPublicAddresses_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamDiscoveredPublicAddressesInput, ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error)) *EC2_GetIpamDiscoveredPublicAddresses_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamDiscoveredResourceCidrs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamDiscoveredResourceCidrs(ctx context.Context, params *ec2.GetIpamDiscoveredResourceCidrsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamDiscoveredResourceCidrs")
	}

	var r0 *ec2.GetIpamDiscoveredResourceCidrsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamDiscoveredResourceCidrsInput, ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamDiscoveredResourceCidrsInput, ...func(*ec2.Options)) *ec2.GetIpamDiscoveredResourceCidrsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamDiscoveredResourceCidrsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamDiscoveredResourceCidrsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamDiscoveredResourceCidrs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamDiscoveredResourceCidrs'
type EC2_GetIpamDiscoveredResourceCidrs_Call struct {
	*mock.Call
}

// GetIpamDiscoveredResourceCidrs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamDiscoveredResourceCidrsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamDiscoveredResourceCidrs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamDiscoveredResourceCidrs_Call {
	return &EC2_GetIpamDiscoveredResourceCidrs_Call{Call: _e.mock.On("GetIpamDiscoveredResourceCidrs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamDiscoveredResourceCidrs_Call) Run(run func(ctx context.Context, params *ec2.GetIpamDiscoveredResourceCidrsInput, optFns ...func(*ec2.Options))) *EC2_GetIpamDiscoveredResourceCidrs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamDiscoveredResourceCidrsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamDiscoveredResourceCidrs_Call) Return(_a0 *ec2.GetIpamDiscoveredResourceCidrsOutput, _a1 error) *EC2_GetIpamDiscoveredResourceCidrs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamDiscoveredResourceCidrs_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamDiscoveredResourceCidrsInput, ...func(*ec2.Options)) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error)) *EC2_GetIpamDiscoveredResourceCidrs_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamPolicyAllocationRules provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamPolicyAllocationRules(ctx context.Context, params *ec2.GetIpamPolicyAllocationRulesInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPolicyAllocationRulesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamPolicyAllocationRules")
	}

	var r0 *ec2.GetIpamPolicyAllocationRulesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) (*ec2.GetIpamPolicyAllocationRulesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) *ec2.GetIpamPolicyAllocationRulesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamPolicyAllocationRulesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamPolicyAllocationRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPolicyAllocationRules'
type EC2_GetIpamPolicyAllocationRules_Call struct {
	*mock.Call
}

// GetIpamPolicyAllocationRules is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamPolicyAllocationRulesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamPolicyAllocationRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPolicyAllocationRules_Call {
	return &EC2_GetIpamPolicyAllocationRules_Call{Call: _e.mock.On("GetIpamPolicyAllocationRules",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamPolicyAllocationRules_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPolicyAllocationRulesInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPolicyAllocationRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamPolicyAllocationRulesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamPolicyAllocationRules_Call) Return(_a0 *ec2.GetIpamPolicyAllocationRulesOutput, _a1 error) *EC2_GetIpamPolicyAllocationRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamPolicyAllocationRules_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) (*ec2.GetIpamPolicyAllocationRulesOutput, error)) *EC2_GetIpamPolicyAllocationRules_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamPolicyOrganizationTargets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamPolicyOrganizationTargets(ctx context.Context, params *ec2.GetIpamPolicyOrganizationTargetsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPolicyOrganizationTargetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamPolicyOrganizationTargets")
	}

	var r0 *ec2.GetIpamPolicyOrganizationTargetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPolicyOrganizationTargetsInput, ...func(*ec2.Options)) (*ec2.GetIpamPolicyOrganizationTargetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPolicyOrganizationTargetsInput, ...func(*ec2.Options)) *ec2.GetIpamPolicyOrganizationTargetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamPolicyOrganizationTargetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPolicyOrganizationTargetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamPolicyOrganizationTargets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPolicyOrganizationTargets'
type EC2_GetIpamPolicyOrganizationTargets_Call struct {
	*mock.Call
}

// GetIpamPolicyOrganizationTargets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamPolicyOrganizationTargetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamPolicyOrganizationTargets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPolicyOrganizationTargets_Call {
	return &EC2_GetIpamPolicyOrganizationTargets_Call{Call: _e.mock.On("GetIpamPolicyOrganizationTargets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamPolicyOrganizationTargets_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPolicyOrganizationTargetsInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPolicyOrganizationTargets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamPolicyOrganizationTargetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamPolicyOrganizationTargets_Call) Return(_a0 *ec2.GetIpamPolicyOrganizationTargetsOutput, _a1 error) *EC2_GetIpamPolicyOrganizationTargets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamPolicyOrganizationTargets_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPolicyOrganizationTargetsInput, ...func(*ec2.Options)) (*ec2.GetIpamPolicyOrganizationTargetsOutput, error)) *EC2_GetIpamPolicyOrganizationTargets_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamPoolAllocations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamPoolAllocations(ctx context.Context, params *ec2.GetIpamPoolAllocationsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPoolAllocationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamPoolAllocations")
	}

	var r0 *ec2.GetIpamPoolAllocationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPoolAllocationsInput, ...func(*ec2.Options)) (*ec2.GetIpamPoolAllocationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPoolAllocationsInput, ...func(*ec2.Options)) *ec2.GetIpamPoolAllocationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamPoolAllocationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPoolAllocationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamPoolAllocations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPoolAllocations'
type EC2_GetIpamPoolAllocations_Call struct {
	*mock.Call
}

// GetIpamPoolAllocations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamPoolAllocationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamPoolAllocations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPoolAllocations_Call {
	return &EC2_GetIpamPoolAllocations_Call{Call: _e.mock.On("GetIpamPoolAllocations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamPoolAllocations_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPoolAllocationsInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPoolAllocations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamPoolAllocationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamPoolAllocations_Call) Return(_a0 *ec2.GetIpamPoolAllocationsOutput, _a1 error) *EC2_GetIpamPoolAllocations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamPoolAllocations_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPoolAllocationsInput, ...func(*ec2.Options)) (*ec2.GetIpamPoolAllocationsOutput, error)) *EC2_GetIpamPoolAllocations_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamPoolCidrs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamPoolCidrs(ctx context.Context, params *ec2.GetIpamPoolCidrsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPoolCidrsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamPoolCidrs")
	}

	var r0 *ec2.GetIpamPoolCidrsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPoolCidrsInput, ...func(*ec2.Options)) (*ec2.GetIpamPoolCidrsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPoolCidrsInput, ...func(*ec2.Options)) *ec2.GetIpamPoolCidrsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamPoolCidrsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPoolCidrsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamPoolCidrs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPoolCidrs'
type EC2_GetIpamPoolCidrs_Call struct {
	*mock.Call
}

// GetIpamPoolCidrs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamPoolCidrsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamPoolCidrs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPoolCidrs_Call {
	return &EC2_GetIpamPoolCidrs_Call{Call: _e.mock.On("GetIpamPoolCidrs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamPoolCidrs_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPoolCidrsInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPoolCidrs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamPoolCidrsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamPoolCidrs_Call) Return(_a0 *ec2.GetIpamPoolCidrsOutput, _a1 error) *EC2_GetIpamPoolCidrs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamPoolCidrs_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPoolCidrsInput, ...func(*ec2.Options)) (*ec2.GetIpamPoolCidrsOutput, error)) *EC2_GetIpamPoolCidrs_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamPrefixListResolverRules provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamPrefixListResolverRules(ctx context.Context, params *ec2.GetIpamPrefixListResolverRulesInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverRulesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamPrefixListResolverRules")
	}

	var r0 *ec2.GetIpamPrefixListResolverRulesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPrefixListResolverRulesInput, ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverRulesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPrefixListResolverRulesInput, ...func(*ec2.Options)) *ec2.GetIpamPrefixListResolverRulesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamPrefixListResolverRulesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPrefixListResolverRulesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamPrefixListResolverRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPrefixListResolverRules'
type EC2_GetIpamPrefixListResolverRules_Call struct {
	*mock.Call
}

// GetIpamPrefixListResolverRules is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamPrefixListResolverRulesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamPrefixListResolverRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPrefixListResolverRules_Call {
	return &EC2_GetIpamPrefixListResolverRules_Call{Call: _e.mock.On("GetIpamPrefixListResolverRules",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamPrefixListResolverRules_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPrefixListResolverRulesInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPrefixListResolverRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamPrefixListResolverRulesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamPrefixListResolverRules_Call) Return(_a0 *ec2.GetIpamPrefixListResolverRulesOutput, _a1 error) *EC2_GetIpamPrefixListResolverRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamPrefixListResolverRules_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPrefixListResolverRulesInput, ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverRulesOutput, error)) *EC2_GetIpamPrefixListResolverRules_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamPrefixListResolverVersionEntries provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamPrefixListResolverVersionEntries(ctx context.Context, params *ec2.GetIpamPrefixListResolverVersionEntriesInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverVersionEntriesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamPrefixListResolverVersionEntries")
	}

	var r0 *ec2.GetIpamPrefixListResolverVersionEntriesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPrefixListResolverVersionEntriesInput, ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverVersionEntriesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPrefixListResolverVersionEntriesInput, ...func(*ec2.Options)) *ec2.GetIpamPrefixListResolverVersionEntriesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamPrefixListResolverVersionEntriesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPrefixListResolverVersionEntriesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamPrefixListResolverVersionEntries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPrefixListResolverVersionEntries'
type EC2_GetIpamPrefixListResolverVersionEntries_Call struct {
	*mock.Call
}

// GetIpamPrefixListResolverVersionEntries is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamPrefixListResolverVersionEntriesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamPrefixListResolverVersionEntries(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPrefixListResolverVersionEntries_Call {
	return &EC2_GetIpamPrefixListResolverVersionEntries_Call{Call: _e.mock.On("GetIpamPrefixListResolverVersionEntries",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamPrefixListResolverVersionEntries_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPrefixListResolverVersionEntriesInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPrefixListResolverVersionEntries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamPrefixListResolverVersionEntriesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamPrefixListResolverVersionEntries_Call) Return(_a0 *ec2.GetIpamPrefixListResolverVersionEntriesOutput, _a1 error) *EC2_GetIpamPrefixListResolverVersionEntries_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamPrefixListResolverVersionEntries_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPrefixListResolverVersionEntriesInput, ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverVersionEntriesOutput, error)) *EC2_GetIpamPrefixListResolverVersionEntries_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamPrefixListResolverVersions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamPrefixListResolverVersions(ctx context.Context, params *ec2.GetIpamPrefixListResolverVersionsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverVersionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamPrefixListResolverVersions")
	}

	var r0 *ec2.GetIpamPrefixListResolverVersionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPrefixListResolverVersionsInput, ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverVersionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamPrefixListResolverVersionsInput, ...func(*ec2.Options)) *ec2.GetIpamPrefixListResolverVersionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamPrefixListResolverVersionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamPrefixListResolverVersionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamPrefixListResolverVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamPrefixListResolverVersions'
type EC2_GetIpamPrefixListResolverVersions_Call struct {
	*mock.Call
}

// GetIpamPrefixListResolverVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamPrefixListResolverVersionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamPrefixListResolverVersions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamPrefixListResolverVersions_Call {
	return &EC2_GetIpamPrefixListResolverVersions_Call{Call: _e.mock.On("GetIpamPrefixListResolverVersions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamPrefixListResolverVersions_Call) Run(run func(ctx context.Context, params *ec2.GetIpamPrefixListResolverVersionsInput, optFns ...func(*ec2.Options))) *EC2_GetIpamPrefixListResolverVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamPrefixListResolverVersionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamPrefixListResolverVersions_Call) Return(_a0 *ec2.GetIpamPrefixListResolverVersionsOutput, _a1 error) *EC2_GetIpamPrefixListResolverVersions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamPrefixListResolverVersions_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamPrefixListResolverVersionsInput, ...func(*ec2.Options)) (*ec2.GetIpamPrefixListResolverVersionsOutput, error)) *EC2_GetIpamPrefixListResolverVersions_Call {
	_c.Call.Return(run)
	return _c
}

// GetIpamResourceCidrs provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetIpamResourceCidrs(ctx context.Context, params *ec2.GetIpamResourceCidrsInput, optFns ...func(*ec2.Options)) (*ec2.GetIpamResourceCidrsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetIpamResourceCidrs")
	}

	var r0 *ec2.GetIpamResourceCidrsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamResourceCidrsInput, ...func(*ec2.Options)) (*ec2.GetIpamResourceCidrsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetIpamResourceCidrsInput, ...func(*ec2.Options)) *ec2.GetIpamResourceCidrsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetIpamResourceCidrsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetIpamResourceCidrsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetIpamResourceCidrs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIpamResourceCidrs'
type EC2_GetIpamResourceCidrs_Call struct {
	*mock.Call
}

// GetIpamResourceCidrs is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetIpamResourceCidrsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetIpamResourceCidrs(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetIpamResourceCidrs_Call {
	return &EC2_GetIpamResourceCidrs_Call{Call: _e.mock.On("GetIpamResourceCidrs",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetIpamResourceCidrs_Call) Run(run func(ctx context.Context, params *ec2.GetIpamResourceCidrsInput, optFns ...func(*ec2.Options))) *EC2_GetIpamResourceCidrs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetIpamResourceCidrsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetIpamResourceCidrs_Call) Return(_a0 *ec2.GetIpamResourceCidrsOutput, _a1 error) *EC2_GetIpamResourceCidrs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetIpamResourceCidrs_Call) RunAndReturn(run func(context.Context, *ec2.GetIpamResourceCidrsInput, ...func(*ec2.Options)) (*ec2.GetIpamResourceCidrsOutput, error)) *EC2_GetIpamResourceCidrs_Call {
	_c.Call.Return(run)
	return _c
}

// GetLaunchTemplateData provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetLaunchTemplateData(ctx context.Context, params *ec2.GetLaunchTemplateDataInput, optFns ...func(*ec2.Options)) (*ec2.GetLaunchTemplateDataOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetLaunchTemplateData")
	}

	var r0 *ec2.GetLaunchTemplateDataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetLaunchTemplateDataInput, ...func(*ec2.Options)) (*ec2.GetLaunchTemplateDataOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetLaunchTemplateDataInput, ...func(*ec2.Options)) *ec2.GetLaunchTemplateDataOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetLaunchTemplateDataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetLaunchTemplateDataInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetLaunchTemplateData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLaunchTemplateData'
type EC2_GetLaunchTemplateData_Call struct {
	*mock.Call
}

// GetLaunchTemplateData is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetLaunchTemplateDataInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetLaunchTemplateData(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetLaunchTemplateData_Call {
	return &EC2_GetLaunchTemplateData_Call{Call: _e.mock.On("GetLaunchTemplateData",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetLaunchTemplateData_Call) Run(run func(ctx context.Context, params *ec2.GetLaunchTemplateDataInput, optFns ...func(*ec2.Options))) *EC2_GetLaunchTemplateData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetLaunchTemplateDataInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetLaunchTemplateData_Call) Return(_a0 *ec2.GetLaunchTemplateDataOutput, _a1 error) *EC2_GetLaunchTemplateData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetLaunchTemplateData_Call) RunAndReturn(run func(context.Context, *ec2.GetLaunchTemplateDataInput, ...func(*ec2.Options)) (*ec2.GetLaunchTemplateDataOutput, error)) *EC2_GetLaunchTemplateData_Call {
	_c.Call.Return(run)
	return _c
}

// GetManagedPrefixListAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetManagedPrefixListAssociations(ctx context.Context, params *ec2.GetManagedPrefixListAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.GetManagedPrefixListAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetManagedPrefixListAssociations")
	}

	var r0 *ec2.GetManagedPrefixListAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetManagedPrefixListAssociationsInput, ...func(*ec2.Options)) (*ec2.GetManagedPrefixListAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetManagedPrefixListAssociationsInput, ...func(*ec2.Options)) *ec2.GetManagedPrefixListAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetManagedPrefixListAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetManagedPrefixListAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetManagedPrefixListAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManagedPrefixListAssociations'
type EC2_GetManagedPrefixListAssociations_Call struct {
	*mock.Call
}

// GetManagedPrefixListAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetManagedPrefixListAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetManagedPrefixListAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetManagedPrefixListAssociations_Call {
	return &EC2_GetManagedPrefixListAssociations_Call{Call: _e.mock.On("GetManagedPrefixListAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetManagedPrefixListAssociations_Call) Run(run func(ctx context.Context, params *ec2.GetManagedPrefixListAssociationsInput, optFns ...func(*ec2.Options))) *EC2_GetManagedPrefixListAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetManagedPrefixListAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetManagedPrefixListAssociations_Call) Return(_a0 *ec2.GetManagedPrefixListAssociationsOutput, _a1 error) *EC2_GetManagedPrefixListAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetManagedPrefixListAssociations_Call) RunAndReturn(run func(context.Context, *ec2.GetManagedPrefixListAssociationsInput, ...func(*ec2.Options)) (*ec2.GetManagedPrefixListAssociationsOutput, error)) *EC2_GetManagedPrefixListAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// GetManagedPrefixListEntries provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetManagedPrefixListEntries(ctx context.Context, params *ec2.GetManagedPrefixListEntriesInput, optFns ...func(*ec2.Options)) (*ec2.GetManagedPrefixListEntriesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetManagedPrefixListEntries")
	}

	var r0 *ec2.GetManagedPrefixListEntriesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetManagedPrefixListEntriesInput, ...func(*ec2.Options)) (*ec2.GetManagedPrefixListEntriesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetManagedPrefixListEntriesInput, ...func(*ec2.Options)) *ec2.GetManagedPrefixListEntriesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetManagedPrefixListEntriesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetManagedPrefixListEntriesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetManagedPrefixListEntries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManagedPrefixListEntries'
type EC2_GetManagedPrefixListEntries_Call struct {
	*mock.Call
}

// GetManagedPrefixListEntries is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetManagedPrefixListEntriesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetManagedPrefixListEntries(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetManagedPrefixListEntries_Call {
	return &EC2_GetManagedPrefixListEntries_Call{Call: _e.mock.On("GetManagedPrefixListEntries",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetManagedPrefixListEntries_Call) Run(run func(ctx context.Context, params *ec2.GetManagedPrefixListEntriesInput, optFns ...func(*ec2.Options))) *EC2_GetManagedPrefixListEntries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetManagedPrefixListEntriesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetManagedPrefixListEntries_Call) Return(_a0 *ec2.GetManagedPrefixListEntriesOutput, _a1 error) *EC2_GetManagedPrefixListEntries_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetManagedPrefixListEntries_Call) RunAndReturn(run func(context.Context, *ec2.GetManagedPrefixListEntriesInput, ...func(*ec2.Options)) (*ec2.GetManagedPrefixListEntriesOutput, error)) *EC2_GetManagedPrefixListEntries_Call {
	_c.Call.Return(run)
	return _c
}

// GetNetworkInsightsAccessScopeAnalysisFindings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetNetworkInsightsAccessScopeAnalysisFindings(ctx context.Context, params *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, optFns ...func(*ec2.Options)) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetNetworkInsightsAccessScopeAnalysisFindings")
	}

	var r0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, ...func(*ec2.Options)) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, ...func(*ec2.Options)) *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetworkInsightsAccessScopeAnalysisFindings'
type EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call struct {
	*mock.Call
}

// GetNetworkInsightsAccessScopeAnalysisFindings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetNetworkInsightsAccessScopeAnalysisFindings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call {
	return &EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call{Call: _e.mock.On("GetNetworkInsightsAccessScopeAnalysisFindings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call) Run(run func(ctx context.Context, params *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, optFns ...func(*ec2.Options))) *EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call) Return(_a0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, _a1 error) *EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call) RunAndReturn(run func(context.Context, *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, ...func(*ec2.Options)) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error)) *EC2_GetNetworkInsightsAccessScopeAnalysisFindings_Call {
	_c.Call.Return(run)
	return _c
}

// GetNetworkInsightsAccessScopeContent provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetNetworkInsightsAccessScopeContent(ctx context.Context, params *ec2.GetNetworkInsightsAccessScopeContentInput, optFns ...func(*ec2.Options)) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetNetworkInsightsAccessScopeContent")
	}

	var r0 *ec2.GetNetworkInsightsAccessScopeContentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetNetworkInsightsAccessScopeContentInput, ...func(*ec2.Options)) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetNetworkInsightsAccessScopeContentInput, ...func(*ec2.Options)) *ec2.GetNetworkInsightsAccessScopeContentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetNetworkInsightsAccessScopeContentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetNetworkInsightsAccessScopeContentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetNetworkInsightsAccessScopeContent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetworkInsightsAccessScopeContent'
type EC2_GetNetworkInsightsAccessScopeContent_Call struct {
	*mock.Call
}

// GetNetworkInsightsAccessScopeContent is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetNetworkInsightsAccessScopeContentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetNetworkInsightsAccessScopeContent(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetNetworkInsightsAccessScopeContent_Call {
	return &EC2_GetNetworkInsightsAccessScopeContent_Call{Call: _e.mock.On("GetNetworkInsightsAccessScopeContent",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetNetworkInsightsAccessScopeContent_Call) Run(run func(ctx context.Context, params *ec2.GetNetworkInsightsAccessScopeContentInput, optFns ...func(*ec2.Options))) *EC2_GetNetworkInsightsAccessScopeContent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetNetworkInsightsAccessScopeContentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetNetworkInsightsAccessScopeContent_Call) Return(_a0 *ec2.GetNetworkInsightsAccessScopeContentOutput, _a1 error) *EC2_GetNetworkInsightsAccessScopeContent_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetNetworkInsightsAccessScopeContent_Call) RunAndReturn(run func(context.Context, *ec2.GetNetworkInsightsAccessScopeContentInput, ...func(*ec2.Options)) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error)) *EC2_GetNetworkInsightsAccessScopeContent_Call {
	_c.Call.Return(run)
	return _c
}

// GetPasswordData provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetPasswordData(ctx context.Context, params *ec2.GetPasswordDataInput, optFns ...func(*ec2.Options)) (*ec2.GetPasswordDataOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetPasswordData")
	}

	var r0 *ec2.GetPasswordDataOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetPasswordDataInput, ...func(*ec2.Options)) (*ec2.GetPasswordDataOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetPasswordDataInput, ...func(*ec2.Options)) *ec2.GetPasswordDataOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetPasswordDataOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetPasswordDataInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetPasswordData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPasswordData'
type EC2_GetPasswordData_Call struct {
	*mock.Call
}

// GetPasswordData is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetPasswordDataInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetPasswordData(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetPasswordData_Call {
	return &EC2_GetPasswordData_Call{Call: _e.mock.On("GetPasswordData",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetPasswordData_Call) Run(run func(ctx context.Context, params *ec2.GetPasswordDataInput, optFns ...func(*ec2.Options))) *EC2_GetPasswordData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetPasswordDataInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetPasswordData_Call) Return(_a0 *ec2.GetPasswordDataOutput, _a1 error) *EC2_GetPasswordData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetPasswordData_Call) RunAndReturn(run func(context.Context, *ec2.GetPasswordDataInput, ...func(*ec2.Options)) (*ec2.GetPasswordDataOutput, error)) *EC2_GetPasswordData_Call {
	_c.Call.Return(run)
	return _c
}

// GetReservedInstancesExchangeQuote provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetReservedInstancesExchangeQuote(ctx context.Context, params *ec2.GetReservedInstancesExchangeQuoteInput, optFns ...func(*ec2.Options)) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetReservedInstancesExchangeQuote")
	}

	var r0 *ec2.GetReservedInstancesExchangeQuoteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetReservedInstancesExchangeQuoteInput, ...func(*ec2.Options)) (*ec2.GetReservedInstancesExchangeQuoteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetReservedInstancesExchangeQuoteInput, ...func(*ec2.Options)) *ec2.GetReservedInstancesExchangeQuoteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetReservedInstancesExchangeQuoteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetReservedInstancesExchangeQuoteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetReservedInstancesExchangeQuote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReservedInstancesExchangeQuote'
type EC2_GetReservedInstancesExchangeQuote_Call struct {
	*mock.Call
}

// GetReservedInstancesExchangeQuote is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetReservedInstancesExchangeQuoteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetReservedInstancesExchangeQuote(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetReservedInstancesExchangeQuote_Call {
	return &EC2_GetReservedInstancesExchangeQuote_Call{Call: _e.mock.On("GetReservedInstancesExchangeQuote",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetReservedInstancesExchangeQuote_Call) Run(run func(ctx context.Context, params *ec2.GetReservedInstancesExchangeQuoteInput, optFns ...func(*ec2.Options))) *EC2_GetReservedInstancesExchangeQuote_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetReservedInstancesExchangeQuoteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetReservedInstancesExchangeQuote_Call) Return(_a0 *ec2.GetReservedInstancesExchangeQuoteOutput, _a1 error) *EC2_GetReservedInstancesExchangeQuote_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetReservedInstancesExchangeQuote_Call) RunAndReturn(run func(context.Context, *ec2.GetReservedInstancesExchangeQuoteInput, ...func(*ec2.Options)) (*ec2.GetReservedInstancesExchangeQuoteOutput, error)) *EC2_GetReservedInstancesExchangeQuote_Call {
	_c.Call.Return(run)
	return _c
}

// GetRouteServerAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetRouteServerAssociations(ctx context.Context, params *ec2.GetRouteServerAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.GetRouteServerAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetRouteServerAssociations")
	}

	var r0 *ec2.GetRouteServerAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetRouteServerAssociationsInput, ...func(*ec2.Options)) (*ec2.GetRouteServerAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetRouteServerAssociationsInput, ...func(*ec2.Options)) *ec2.GetRouteServerAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetRouteServerAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetRouteServerAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetRouteServerAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRouteServerAssociations'
type EC2_GetRouteServerAssociations_Call struct {
	*mock.Call
}

// GetRouteServerAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetRouteServerAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetRouteServerAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetRouteServerAssociations_Call {
	return &EC2_GetRouteServerAssociations_Call{Call: _e.mock.On("GetRouteServerAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetRouteServerAssociations_Call) Run(run func(ctx context.Context, params *ec2.GetRouteServerAssociationsInput, optFns ...func(*ec2.Options))) *EC2_GetRouteServerAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetRouteServerAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetRouteServerAssociations_Call) Return(_a0 *ec2.GetRouteServerAssociationsOutput, _a1 error) *EC2_GetRouteServerAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetRouteServerAssociations_Call) RunAndReturn(run func(context.Context, *ec2.GetRouteServerAssociationsInput, ...func(*ec2.Options)) (*ec2.GetRouteServerAssociationsOutput, error)) *EC2_GetRouteServerAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// GetRouteServerPropagations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetRouteServerPropagations(ctx context.Context, params *ec2.GetRouteServerPropagationsInput, optFns ...func(*ec2.Options)) (*ec2.GetRouteServerPropagationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetRouteServerPropagations")
	}

	var r0 *ec2.GetRouteServerPropagationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetRouteServerPropagationsInput, ...func(*ec2.Options)) (*ec2.GetRouteServerPropagationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetRouteServerPropagationsInput, ...func(*ec2.Options)) *ec2.GetRouteServerPropagationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetRouteServerPropagationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetRouteServerPropagationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetRouteServerPropagations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRouteServerPropagations'
type EC2_GetRouteServerPropagations_Call struct {
	*mock.Call
}

// GetRouteServerPropagations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetRouteServerPropagationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetRouteServerPropagations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetRouteServerPropagations_Call {
	return &EC2_GetRouteServerPropagations_Call{Call: _e.mock.On("GetRouteServerPropagations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetRouteServerPropagations_Call) Run(run func(ctx context.Context, params *ec2.GetRouteServerPropagationsInput, optFns ...func(*ec2.Options))) *EC2_GetRouteServerPropagations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetRouteServerPropagationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetRouteServerPropagations_Call) Return(_a0 *ec2.GetRouteServerPropagationsOutput, _a1 error) *EC2_GetRouteServerPropagations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetRouteServerPropagations_Call) RunAndReturn(run func(context.Context, *ec2.GetRouteServerPropagationsInput, ...func(*ec2.Options)) (*ec2.GetRouteServerPropagationsOutput, error)) *EC2_GetRouteServerPropagations_Call {
	_c.Call.Return(run)
	return _c
}

// GetRouteServerRoutingDatabase provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetRouteServerRoutingDatabase(ctx context.Context, params *ec2.GetRouteServerRoutingDatabaseInput, optFns ...func(*ec2.Options)) (*ec2.GetRouteServerRoutingDatabaseOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetRouteServerRoutingDatabase")
	}

	var r0 *ec2.GetRouteServerRoutingDatabaseOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetRouteServerRoutingDatabaseInput, ...func(*ec2.Options)) (*ec2.GetRouteServerRoutingDatabaseOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetRouteServerRoutingDatabaseInput, ...func(*ec2.Options)) *ec2.GetRouteServerRoutingDatabaseOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetRouteServerRoutingDatabaseOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetRouteServerRoutingDatabaseInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetRouteServerRoutingDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRouteServerRoutingDatabase'
type EC2_GetRouteServerRoutingDatabase_Call struct {
	*mock.Call
}

// GetRouteServerRoutingDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetRouteServerRoutingDatabaseInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetRouteServerRoutingDatabase(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetRouteServerRoutingDatabase_Call {
	return &EC2_GetRouteServerRoutingDatabase_Call{Call: _e.mock.On("GetRouteServerRoutingDatabase",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetRouteServerRoutingDatabase_Call) Run(run func(ctx context.Context, params *ec2.GetRouteServerRoutingDatabaseInput, optFns ...func(*ec2.Options))) *EC2_GetRouteServerRoutingDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetRouteServerRoutingDatabaseInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetRouteServerRoutingDatabase_Call) Return(_a0 *ec2.GetRouteServerRoutingDatabaseOutput, _a1 error) *EC2_GetRouteServerRoutingDatabase_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetRouteServerRoutingDatabase_Call) RunAndReturn(run func(context.Context, *ec2.GetRouteServerRoutingDatabaseInput, ...func(*ec2.Options)) (*ec2.GetRouteServerRoutingDatabaseOutput, error)) *EC2_GetRouteServerRoutingDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// GetSecurityGroupsForVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetSecurityGroupsForVpc(ctx context.Context, params *ec2.GetSecurityGroupsForVpcInput, optFns ...func(*ec2.Options)) (*ec2.GetSecurityGroupsForVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetSecurityGroupsForVpc")
	}

	var r0 *ec2.GetSecurityGroupsForVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSecurityGroupsForVpcInput, ...func(*ec2.Options)) (*ec2.GetSecurityGroupsForVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSecurityGroupsForVpcInput, ...func(*ec2.Options)) *ec2.GetSecurityGroupsForVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetSecurityGroupsForVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetSecurityGroupsForVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetSecurityGroupsForVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecurityGroupsForVpc'
type EC2_GetSecurityGroupsForVpc_Call struct {
	*mock.Call
}

// GetSecurityGroupsForVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetSecurityGroupsForVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetSecurityGroupsForVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetSecurityGroupsForVpc_Call {
	return &EC2_GetSecurityGroupsForVpc_Call{Call: _e.mock.On("GetSecurityGroupsForVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetSecurityGroupsForVpc_Call) Run(run func(ctx context.Context, params *ec2.GetSecurityGroupsForVpcInput, optFns ...func(*ec2.Options))) *EC2_GetSecurityGroupsForVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetSecurityGroupsForVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetSecurityGroupsForVpc_Call) Return(_a0 *ec2.GetSecurityGroupsForVpcOutput, _a1 error) *EC2_GetSecurityGroupsForVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetSecurityGroupsForVpc_Call) RunAndReturn(run func(context.Context, *ec2.GetSecurityGroupsForVpcInput, ...func(*ec2.Options)) (*ec2.GetSecurityGroupsForVpcOutput, error)) *EC2_GetSecurityGroupsForVpc_Call {
	_c.Call.Return(run)
	return _c
}

// GetSerialConsoleAccessStatus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetSerialConsoleAccessStatus(ctx context.Context, params *ec2.GetSerialConsoleAccessStatusInput, optFns ...func(*ec2.Options)) (*ec2.GetSerialConsoleAccessStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetSerialConsoleAccessStatus")
	}

	var r0 *ec2.GetSerialConsoleAccessStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSerialConsoleAccessStatusInput, ...func(*ec2.Options)) (*ec2.GetSerialConsoleAccessStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSerialConsoleAccessStatusInput, ...func(*ec2.Options)) *ec2.GetSerialConsoleAccessStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetSerialConsoleAccessStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetSerialConsoleAccessStatusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetSerialConsoleAccessStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSerialConsoleAccessStatus'
type EC2_GetSerialConsoleAccessStatus_Call struct {
	*mock.Call
}

// GetSerialConsoleAccessStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetSerialConsoleAccessStatusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetSerialConsoleAccessStatus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetSerialConsoleAccessStatus_Call {
	return &EC2_GetSerialConsoleAccessStatus_Call{Call: _e.mock.On("GetSerialConsoleAccessStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetSerialConsoleAccessStatus_Call) Run(run func(ctx context.Context, params *ec2.GetSerialConsoleAccessStatusInput, optFns ...func(*ec2.Options))) *EC2_GetSerialConsoleAccessStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetSerialConsoleAccessStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetSerialConsoleAccessStatus_Call) Return(_a0 *ec2.GetSerialConsoleAccessStatusOutput, _a1 error) *EC2_GetSerialConsoleAccessStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetSerialConsoleAccessStatus_Call) RunAndReturn(run func(context.Context, *ec2.GetSerialConsoleAccessStatusInput, ...func(*ec2.Options)) (*ec2.GetSerialConsoleAccessStatusOutput, error)) *EC2_GetSerialConsoleAccessStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetSnapshotBlockPublicAccessState provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetSnapshotBlockPublicAccessState(ctx context.Context, params *ec2.GetSnapshotBlockPublicAccessStateInput, optFns ...func(*ec2.Options)) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetSnapshotBlockPublicAccessState")
	}

	var r0 *ec2.GetSnapshotBlockPublicAccessStateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSnapshotBlockPublicAccessStateInput, ...func(*ec2.Options)) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSnapshotBlockPublicAccessStateInput, ...func(*ec2.Options)) *ec2.GetSnapshotBlockPublicAccessStateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetSnapshotBlockPublicAccessStateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetSnapshotBlockPublicAccessStateInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetSnapshotBlockPublicAccessState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSnapshotBlockPublicAccessState'
type EC2_GetSnapshotBlockPublicAccessState_Call struct {
	*mock.Call
}

// GetSnapshotBlockPublicAccessState is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetSnapshotBlockPublicAccessStateInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetSnapshotBlockPublicAccessState(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetSnapshotBlockPublicAccessState_Call {
	return &EC2_GetSnapshotBlockPublicAccessState_Call{Call: _e.mock.On("GetSnapshotBlockPublicAccessState",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetSnapshotBlockPublicAccessState_Call) Run(run func(ctx context.Context, params *ec2.GetSnapshotBlockPublicAccessStateInput, optFns ...func(*ec2.Options))) *EC2_GetSnapshotBlockPublicAccessState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetSnapshotBlockPublicAccessStateInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetSnapshotBlockPublicAccessState_Call) Return(_a0 *ec2.GetSnapshotBlockPublicAccessStateOutput, _a1 error) *EC2_GetSnapshotBlockPublicAccessState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetSnapshotBlockPublicAccessState_Call) RunAndReturn(run func(context.Context, *ec2.GetSnapshotBlockPublicAccessStateInput, ...func(*ec2.Options)) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error)) *EC2_GetSnapshotBlockPublicAccessState_Call {
	_c.Call.Return(run)
	return _c
}

// GetSpotPlacementScores provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetSpotPlacementScores(ctx context.Context, params *ec2.GetSpotPlacementScoresInput, optFns ...func(*ec2.Options)) (*ec2.GetSpotPlacementScoresOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetSpotPlacementScores")
	}

	var r0 *ec2.GetSpotPlacementScoresOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSpotPlacementScoresInput, ...func(*ec2.Options)) (*ec2.GetSpotPlacementScoresOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSpotPlacementScoresInput, ...func(*ec2.Options)) *ec2.GetSpotPlacementScoresOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetSpotPlacementScoresOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetSpotPlacementScoresInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetSpotPlacementScores_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpotPlacementScores'
type EC2_GetSpotPlacementScores_Call struct {
	*mock.Call
}

// GetSpotPlacementScores is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetSpotPlacementScoresInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetSpotPlacementScores(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetSpotPlacementScores_Call {
	return &EC2_GetSpotPlacementScores_Call{Call: _e.mock.On("GetSpotPlacementScores",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetSpotPlacementScores_Call) Run(run func(ctx context.Context, params *ec2.GetSpotPlacementScoresInput, optFns ...func(*ec2.Options))) *EC2_GetSpotPlacementScores_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetSpotPlacementScoresInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetSpotPlacementScores_Call) Return(_a0 *ec2.GetSpotPlacementScoresOutput, _a1 error) *EC2_GetSpotPlacementScores_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetSpotPlacementScores_Call) RunAndReturn(run func(context.Context, *ec2.GetSpotPlacementScoresInput, ...func(*ec2.Options)) (*ec2.GetSpotPlacementScoresOutput, error)) *EC2_GetSpotPlacementScores_Call {
	_c.Call.Return(run)
	return _c
}

// GetSubnetCidrReservations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetSubnetCidrReservations(ctx context.Context, params *ec2.GetSubnetCidrReservationsInput, optFns ...func(*ec2.Options)) (*ec2.GetSubnetCidrReservationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetSubnetCidrReservations")
	}

	var r0 *ec2.GetSubnetCidrReservationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSubnetCidrReservationsInput, ...func(*ec2.Options)) (*ec2.GetSubnetCidrReservationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetSubnetCidrReservationsInput, ...func(*ec2.Options)) *ec2.GetSubnetCidrReservationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetSubnetCidrReservationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetSubnetCidrReservationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetSubnetCidrReservations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSubnetCidrReservations'
type EC2_GetSubnetCidrReservations_Call struct {
	*mock.Call
}

// GetSubnetCidrReservations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetSubnetCidrReservationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetSubnetCidrReservations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetSubnetCidrReservations_Call {
	return &EC2_GetSubnetCidrReservations_Call{Call: _e.mock.On("GetSubnetCidrReservations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetSubnetCidrReservations_Call) Run(run func(ctx context.Context, params *ec2.GetSubnetCidrReservationsInput, optFns ...func(*ec2.Options))) *EC2_GetSubnetCidrReservations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetSubnetCidrReservationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetSubnetCidrReservations_Call) Return(_a0 *ec2.GetSubnetCidrReservationsOutput, _a1 error) *EC2_GetSubnetCidrReservations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetSubnetCidrReservations_Call) RunAndReturn(run func(context.Context, *ec2.GetSubnetCidrReservationsInput, ...func(*ec2.Options)) (*ec2.GetSubnetCidrReservationsOutput, error)) *EC2_GetSubnetCidrReservations_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransitGatewayAttachmentPropagations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetTransitGatewayAttachmentPropagations(ctx context.Context, params *ec2.GetTransitGatewayAttachmentPropagationsInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTransitGatewayAttachmentPropagations")
	}

	var r0 *ec2.GetTransitGatewayAttachmentPropagationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayAttachmentPropagationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayAttachmentPropagationsInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayAttachmentPropagationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayAttachmentPropagationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetTransitGatewayAttachmentPropagations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayAttachmentPropagations'
type EC2_GetTransitGatewayAttachmentPropagations_Call struct {
	*mock.Call
}

// GetTransitGatewayAttachmentPropagations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetTransitGatewayAttachmentPropagationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetTransitGatewayAttachmentPropagations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayAttachmentPropagations_Call {
	return &EC2_GetTransitGatewayAttachmentPropagations_Call{Call: _e.mock.On("GetTransitGatewayAttachmentPropagations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetTransitGatewayAttachmentPropagations_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayAttachmentPropagationsInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayAttachmentPropagations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayAttachmentPropagationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetTransitGatewayAttachmentPropagations_Call) Return(_a0 *ec2.GetTransitGatewayAttachmentPropagationsOutput, _a1 error) *EC2_GetTransitGatewayAttachmentPropagations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetTransitGatewayAttachmentPropagations_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayAttachmentPropagationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error)) *EC2_GetTransitGatewayAttachmentPropagations_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransitGatewayMeteringPolicyEntries provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetTransitGatewayMeteringPolicyEntries(ctx context.Context, params *ec2.GetTransitGatewayMeteringPolicyEntriesInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayMeteringPolicyEntriesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTransitGatewayMeteringPolicyEntries")
	}

	var r0 *ec2.GetTransitGatewayMeteringPolicyEntriesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayMeteringPolicyEntriesInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayMeteringPolicyEntriesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayMeteringPolicyEntriesInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayMeteringPolicyEntriesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayMeteringPolicyEntriesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayMeteringPolicyEntriesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetTransitGatewayMeteringPolicyEntries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayMeteringPolicyEntries'
type EC2_GetTransitGatewayMeteringPolicyEntries_Call struct {
	*mock.Call
}

// GetTransitGatewayMeteringPolicyEntries is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetTransitGatewayMeteringPolicyEntriesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetTransitGatewayMeteringPolicyEntries(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayMeteringPolicyEntries_Call {
	return &EC2_GetTransitGatewayMeteringPolicyEntries_Call{Call: _e.mock.On("GetTransitGatewayMeteringPolicyEntries",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetTransitGatewayMeteringPolicyEntries_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayMeteringPolicyEntriesInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayMeteringPolicyEntries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayMeteringPolicyEntriesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetTransitGatewayMeteringPolicyEntries_Call) Return(_a0 *ec2.GetTransitGatewayMeteringPolicyEntriesOutput, _a1 error) *EC2_GetTransitGatewayMeteringPolicyEntries_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetTransitGatewayMeteringPolicyEntries_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayMeteringPolicyEntriesInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayMeteringPolicyEntriesOutput, error)) *EC2_GetTransitGatewayMeteringPolicyEntries_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransitGatewayMulticastDomainAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetTransitGatewayMulticastDomainAssociations(ctx context.Context, params *ec2.GetTransitGatewayMulticastDomainAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTransitGatewayMulticastDomainAssociations")
	}

	var r0 *ec2.GetTransitGatewayMulticastDomainAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetTransitGatewayMulticastDomainAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayMulticastDomainAssociations'
type EC2_GetTransitGatewayMulticastDomainAssociations_Call struct {
	*mock.Call
}

// GetTransitGatewayMulticastDomainAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetTransitGatewayMulticastDomainAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetTransitGatewayMulticastDomainAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayMulticastDomainAssociations_Call {
	return &EC2_GetTransitGatewayMulticastDomainAssociations_Call{Call: _e.mock.On("GetTransitGatewayMulticastDomainAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetTransitGatewayMulticastDomainAssociations_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayMulticastDomainAssociationsInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayMulticastDomainAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetTransitGatewayMulticastDomainAssociations_Call) Return(_a0 *ec2.GetTransitGatewayMulticastDomainAssociationsOutput, _a1 error) *EC2_GetTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetTransitGatewayMulticastDomainAssociations_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error)) *EC2_GetTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransitGatewayPolicyTableAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetTransitGatewayPolicyTableAssociations(ctx context.Context, params *ec2.GetTransitGatewayPolicyTableAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTransitGatewayPolicyTableAssociations")
	}

	var r0 *ec2.GetTransitGatewayPolicyTableAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayPolicyTableAssociationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayPolicyTableAssociationsInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayPolicyTableAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayPolicyTableAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayPolicyTableAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetTransitGatewayPolicyTableAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayPolicyTableAssociations'
type EC2_GetTransitGatewayPolicyTableAssociations_Call struct {
	*mock.Call
}

// GetTransitGatewayPolicyTableAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetTransitGatewayPolicyTableAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetTransitGatewayPolicyTableAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayPolicyTableAssociations_Call {
	return &EC2_GetTransitGatewayPolicyTableAssociations_Call{Call: _e.mock.On("GetTransitGatewayPolicyTableAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetTransitGatewayPolicyTableAssociations_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayPolicyTableAssociationsInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayPolicyTableAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayPolicyTableAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetTransitGatewayPolicyTableAssociations_Call) Return(_a0 *ec2.GetTransitGatewayPolicyTableAssociationsOutput, _a1 error) *EC2_GetTransitGatewayPolicyTableAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetTransitGatewayPolicyTableAssociations_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayPolicyTableAssociationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error)) *EC2_GetTransitGatewayPolicyTableAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransitGatewayPolicyTableEntries provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetTransitGatewayPolicyTableEntries(ctx context.Context, params *ec2.GetTransitGatewayPolicyTableEntriesInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTransitGatewayPolicyTableEntries")
	}

	var r0 *ec2.GetTransitGatewayPolicyTableEntriesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayPolicyTableEntriesInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayPolicyTableEntriesInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayPolicyTableEntriesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayPolicyTableEntriesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayPolicyTableEntriesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetTransitGatewayPolicyTableEntries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayPolicyTableEntries'
type EC2_GetTransitGatewayPolicyTableEntries_Call struct {
	*mock.Call
}

// GetTransitGatewayPolicyTableEntries is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetTransitGatewayPolicyTableEntriesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetTransitGatewayPolicyTableEntries(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayPolicyTableEntries_Call {
	return &EC2_GetTransitGatewayPolicyTableEntries_Call{Call: _e.mock.On("GetTransitGatewayPolicyTableEntries",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetTransitGatewayPolicyTableEntries_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayPolicyTableEntriesInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayPolicyTableEntries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayPolicyTableEntriesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetTransitGatewayPolicyTableEntries_Call) Return(_a0 *ec2.GetTransitGatewayPolicyTableEntriesOutput, _a1 error) *EC2_GetTransitGatewayPolicyTableEntries_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetTransitGatewayPolicyTableEntries_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayPolicyTableEntriesInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error)) *EC2_GetTransitGatewayPolicyTableEntries_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransitGatewayPrefixListReferences provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetTransitGatewayPrefixListReferences(ctx context.Context, params *ec2.GetTransitGatewayPrefixListReferencesInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTransitGatewayPrefixListReferences")
	}

	var r0 *ec2.GetTransitGatewayPrefixListReferencesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayPrefixListReferencesInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayPrefixListReferencesInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayPrefixListReferencesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayPrefixListReferencesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayPrefixListReferencesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetTransitGatewayPrefixListReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayPrefixListReferences'
type EC2_GetTransitGatewayPrefixListReferences_Call struct {
	*mock.Call
}

// GetTransitGatewayPrefixListReferences is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetTransitGatewayPrefixListReferencesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetTransitGatewayPrefixListReferences(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayPrefixListReferences_Call {
	return &EC2_GetTransitGatewayPrefixListReferences_Call{Call: _e.mock.On("GetTransitGatewayPrefixListReferences",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetTransitGatewayPrefixListReferences_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayPrefixListReferencesInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayPrefixListReferences_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayPrefixListReferencesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetTransitGatewayPrefixListReferences_Call) Return(_a0 *ec2.GetTransitGatewayPrefixListReferencesOutput, _a1 error) *EC2_GetTransitGatewayPrefixListReferences_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetTransitGatewayPrefixListReferences_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayPrefixListReferencesInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error)) *EC2_GetTransitGatewayPrefixListReferences_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransitGatewayRouteTableAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetTransitGatewayRouteTableAssociations(ctx context.Context, params *ec2.GetTransitGatewayRouteTableAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTransitGatewayRouteTableAssociations")
	}

	var r0 *ec2.GetTransitGatewayRouteTableAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayRouteTableAssociationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayRouteTableAssociationsInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayRouteTableAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayRouteTableAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetTransitGatewayRouteTableAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayRouteTableAssociations'
type EC2_GetTransitGatewayRouteTableAssociations_Call struct {
	*mock.Call
}

// GetTransitGatewayRouteTableAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetTransitGatewayRouteTableAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetTransitGatewayRouteTableAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayRouteTableAssociations_Call {
	return &EC2_GetTransitGatewayRouteTableAssociations_Call{Call: _e.mock.On("GetTransitGatewayRouteTableAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetTransitGatewayRouteTableAssociations_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayRouteTableAssociationsInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayRouteTableAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayRouteTableAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetTransitGatewayRouteTableAssociations_Call) Return(_a0 *ec2.GetTransitGatewayRouteTableAssociationsOutput, _a1 error) *EC2_GetTransitGatewayRouteTableAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetTransitGatewayRouteTableAssociations_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayRouteTableAssociationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error)) *EC2_GetTransitGatewayRouteTableAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransitGatewayRouteTablePropagations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetTransitGatewayRouteTablePropagations(ctx context.Context, params *ec2.GetTransitGatewayRouteTablePropagationsInput, optFns ...func(*ec2.Options)) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTransitGatewayRouteTablePropagations")
	}

	var r0 *ec2.GetTransitGatewayRouteTablePropagationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayRouteTablePropagationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetTransitGatewayRouteTablePropagationsInput, ...func(*ec2.Options)) *ec2.GetTransitGatewayRouteTablePropagationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetTransitGatewayRouteTablePropagationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetTransitGatewayRouteTablePropagations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransitGatewayRouteTablePropagations'
type EC2_GetTransitGatewayRouteTablePropagations_Call struct {
	*mock.Call
}

// GetTransitGatewayRouteTablePropagations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetTransitGatewayRouteTablePropagationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetTransitGatewayRouteTablePropagations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetTransitGatewayRouteTablePropagations_Call {
	return &EC2_GetTransitGatewayRouteTablePropagations_Call{Call: _e.mock.On("GetTransitGatewayRouteTablePropagations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetTransitGatewayRouteTablePropagations_Call) Run(run func(ctx context.Context, params *ec2.GetTransitGatewayRouteTablePropagationsInput, optFns ...func(*ec2.Options))) *EC2_GetTransitGatewayRouteTablePropagations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetTransitGatewayRouteTablePropagationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetTransitGatewayRouteTablePropagations_Call) Return(_a0 *ec2.GetTransitGatewayRouteTablePropagationsOutput, _a1 error) *EC2_GetTransitGatewayRouteTablePropagations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetTransitGatewayRouteTablePropagations_Call) RunAndReturn(run func(context.Context, *ec2.GetTransitGatewayRouteTablePropagationsInput, ...func(*ec2.Options)) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error)) *EC2_GetTransitGatewayRouteTablePropagations_Call {
	_c.Call.Return(run)
	return _c
}

// GetVerifiedAccessEndpointPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetVerifiedAccessEndpointPolicy(ctx context.Context, params *ec2.GetVerifiedAccessEndpointPolicyInput, optFns ...func(*ec2.Options)) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetVerifiedAccessEndpointPolicy")
	}

	var r0 *ec2.GetVerifiedAccessEndpointPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVerifiedAccessEndpointPolicyInput, ...func(*ec2.Options)) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVerifiedAccessEndpointPolicyInput, ...func(*ec2.Options)) *ec2.GetVerifiedAccessEndpointPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetVerifiedAccessEndpointPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetVerifiedAccessEndpointPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetVerifiedAccessEndpointPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVerifiedAccessEndpointPolicy'
type EC2_GetVerifiedAccessEndpointPolicy_Call struct {
	*mock.Call
}

// GetVerifiedAccessEndpointPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetVerifiedAccessEndpointPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetVerifiedAccessEndpointPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetVerifiedAccessEndpointPolicy_Call {
	return &EC2_GetVerifiedAccessEndpointPolicy_Call{Call: _e.mock.On("GetVerifiedAccessEndpointPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetVerifiedAccessEndpointPolicy_Call) Run(run func(ctx context.Context, params *ec2.GetVerifiedAccessEndpointPolicyInput, optFns ...func(*ec2.Options))) *EC2_GetVerifiedAccessEndpointPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetVerifiedAccessEndpointPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetVerifiedAccessEndpointPolicy_Call) Return(_a0 *ec2.GetVerifiedAccessEndpointPolicyOutput, _a1 error) *EC2_GetVerifiedAccessEndpointPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetVerifiedAccessEndpointPolicy_Call) RunAndReturn(run func(context.Context, *ec2.GetVerifiedAccessEndpointPolicyInput, ...func(*ec2.Options)) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error)) *EC2_GetVerifiedAccessEndpointPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetVerifiedAccessEndpointTargets provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetVerifiedAccessEndpointTargets(ctx context.Context, params *ec2.GetVerifiedAccessEndpointTargetsInput, optFns ...func(*ec2.Options)) (*ec2.GetVerifiedAccessEndpointTargetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetVerifiedAccessEndpointTargets")
	}

	var r0 *ec2.GetVerifiedAccessEndpointTargetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVerifiedAccessEndpointTargetsInput, ...func(*ec2.Options)) (*ec2.GetVerifiedAccessEndpointTargetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVerifiedAccessEndpointTargetsInput, ...func(*ec2.Options)) *ec2.GetVerifiedAccessEndpointTargetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetVerifiedAccessEndpointTargetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetVerifiedAccessEndpointTargetsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetVerifiedAccessEndpointTargets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVerifiedAccessEndpointTargets'
type EC2_GetVerifiedAccessEndpointTargets_Call struct {
	*mock.Call
}

// GetVerifiedAccessEndpointTargets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetVerifiedAccessEndpointTargetsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetVerifiedAccessEndpointTargets(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetVerifiedAccessEndpointTargets_Call {
	return &EC2_GetVerifiedAccessEndpointTargets_Call{Call: _e.mock.On("GetVerifiedAccessEndpointTargets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetVerifiedAccessEndpointTargets_Call) Run(run func(ctx context.Context, params *ec2.GetVerifiedAccessEndpointTargetsInput, optFns ...func(*ec2.Options))) *EC2_GetVerifiedAccessEndpointTargets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetVerifiedAccessEndpointTargetsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetVerifiedAccessEndpointTargets_Call) Return(_a0 *ec2.GetVerifiedAccessEndpointTargetsOutput, _a1 error) *EC2_GetVerifiedAccessEndpointTargets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetVerifiedAccessEndpointTargets_Call) RunAndReturn(run func(context.Context, *ec2.GetVerifiedAccessEndpointTargetsInput, ...func(*ec2.Options)) (*ec2.GetVerifiedAccessEndpointTargetsOutput, error)) *EC2_GetVerifiedAccessEndpointTargets_Call {
	_c.Call.Return(run)
	return _c
}

// GetVerifiedAccessGroupPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetVerifiedAccessGroupPolicy(ctx context.Context, params *ec2.GetVerifiedAccessGroupPolicyInput, optFns ...func(*ec2.Options)) (*ec2.GetVerifiedAccessGroupPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetVerifiedAccessGroupPolicy")
	}

	var r0 *ec2.GetVerifiedAccessGroupPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVerifiedAccessGroupPolicyInput, ...func(*ec2.Options)) (*ec2.GetVerifiedAccessGroupPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVerifiedAccessGroupPolicyInput, ...func(*ec2.Options)) *ec2.GetVerifiedAccessGroupPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetVerifiedAccessGroupPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetVerifiedAccessGroupPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetVerifiedAccessGroupPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVerifiedAccessGroupPolicy'
type EC2_GetVerifiedAccessGroupPolicy_Call struct {
	*mock.Call
}

// GetVerifiedAccessGroupPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetVerifiedAccessGroupPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetVerifiedAccessGroupPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetVerifiedAccessGroupPolicy_Call {
	return &EC2_GetVerifiedAccessGroupPolicy_Call{Call: _e.mock.On("GetVerifiedAccessGroupPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetVerifiedAccessGroupPolicy_Call) Run(run func(ctx context.Context, params *ec2.GetVerifiedAccessGroupPolicyInput, optFns ...func(*ec2.Options))) *EC2_GetVerifiedAccessGroupPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetVerifiedAccessGroupPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetVerifiedAccessGroupPolicy_Call) Return(_a0 *ec2.GetVerifiedAccessGroupPolicyOutput, _a1 error) *EC2_GetVerifiedAccessGroupPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetVerifiedAccessGroupPolicy_Call) RunAndReturn(run func(context.Context, *ec2.GetVerifiedAccessGroupPolicyInput, ...func(*ec2.Options)) (*ec2.GetVerifiedAccessGroupPolicyOutput, error)) *EC2_GetVerifiedAccessGroupPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetVpcResourcesBlockingEncryptionEnforcement provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetVpcResourcesBlockingEncryptionEnforcement(ctx context.Context, params *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, optFns ...func(*ec2.Options)) (*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetVpcResourcesBlockingEncryptionEnforcement")
	}

	var r0 *ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, ...func(*ec2.Options)) (*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, ...func(*ec2.Options)) *ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVpcResourcesBlockingEncryptionEnforcement'
type EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call struct {
	*mock.Call
}

// GetVpcResourcesBlockingEncryptionEnforcement is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetVpcResourcesBlockingEncryptionEnforcement(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call {
	return &EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call{Call: _e.mock.On("GetVpcResourcesBlockingEncryptionEnforcement",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call) Run(run func(ctx context.Context, params *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, optFns ...func(*ec2.Options))) *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetVpcResourcesBlockingEncryptionEnforcementInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call) Return(_a0 *ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, _a1 error) *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call) RunAndReturn(run func(context.Context, *ec2.GetVpcResourcesBlockingEncryptionEnforcementInput, ...func(*ec2.Options)) (*ec2.GetVpcResourcesBlockingEncryptionEnforcementOutput, error)) *EC2_GetVpcResourcesBlockingEncryptionEnforcement_Call {
	_c.Call.Return(run)
	return _c
}

// GetVpnConnectionDeviceSampleConfiguration provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetVpnConnectionDeviceSampleConfiguration(ctx context.Context, params *ec2.GetVpnConnectionDeviceSampleConfigurationInput, optFns ...func(*ec2.Options)) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetVpnConnectionDeviceSampleConfiguration")
	}

	var r0 *ec2.GetVpnConnectionDeviceSampleConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpnConnectionDeviceSampleConfigurationInput, ...func(*ec2.Options)) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpnConnectionDeviceSampleConfigurationInput, ...func(*ec2.Options)) *ec2.GetVpnConnectionDeviceSampleConfigurationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetVpnConnectionDeviceSampleConfigurationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetVpnConnectionDeviceSampleConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVpnConnectionDeviceSampleConfiguration'
type EC2_GetVpnConnectionDeviceSampleConfiguration_Call struct {
	*mock.Call
}

// GetVpnConnectionDeviceSampleConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetVpnConnectionDeviceSampleConfigurationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetVpnConnectionDeviceSampleConfiguration(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetVpnConnectionDeviceSampleConfiguration_Call {
	return &EC2_GetVpnConnectionDeviceSampleConfiguration_Call{Call: _e.mock.On("GetVpnConnectionDeviceSampleConfiguration",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetVpnConnectionDeviceSampleConfiguration_Call) Run(run func(ctx context.Context, params *ec2.GetVpnConnectionDeviceSampleConfigurationInput, optFns ...func(*ec2.Options))) *EC2_GetVpnConnectionDeviceSampleConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetVpnConnectionDeviceSampleConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetVpnConnectionDeviceSampleConfiguration_Call) Return(_a0 *ec2.GetVpnConnectionDeviceSampleConfigurationOutput, _a1 error) *EC2_GetVpnConnectionDeviceSampleConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetVpnConnectionDeviceSampleConfiguration_Call) RunAndReturn(run func(context.Context, *ec2.GetVpnConnectionDeviceSampleConfigurationInput, ...func(*ec2.Options)) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error)) *EC2_GetVpnConnectionDeviceSampleConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// GetVpnConnectionDeviceTypes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetVpnConnectionDeviceTypes(ctx context.Context, params *ec2.GetVpnConnectionDeviceTypesInput, optFns ...func(*ec2.Options)) (*ec2.GetVpnConnectionDeviceTypesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetVpnConnectionDeviceTypes")
	}

	var r0 *ec2.GetVpnConnectionDeviceTypesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpnConnectionDeviceTypesInput, ...func(*ec2.Options)) (*ec2.GetVpnConnectionDeviceTypesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpnConnectionDeviceTypesInput, ...func(*ec2.Options)) *ec2.GetVpnConnectionDeviceTypesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetVpnConnectionDeviceTypesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetVpnConnectionDeviceTypesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetVpnConnectionDeviceTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVpnConnectionDeviceTypes'
type EC2_GetVpnConnectionDeviceTypes_Call struct {
	*mock.Call
}

// GetVpnConnectionDeviceTypes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetVpnConnectionDeviceTypesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetVpnConnectionDeviceTypes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetVpnConnectionDeviceTypes_Call {
	return &EC2_GetVpnConnectionDeviceTypes_Call{Call: _e.mock.On("GetVpnConnectionDeviceTypes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetVpnConnectionDeviceTypes_Call) Run(run func(ctx context.Context, params *ec2.GetVpnConnectionDeviceTypesInput, optFns ...func(*ec2.Options))) *EC2_GetVpnConnectionDeviceTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetVpnConnectionDeviceTypesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetVpnConnectionDeviceTypes_Call) Return(_a0 *ec2.GetVpnConnectionDeviceTypesOutput, _a1 error) *EC2_GetVpnConnectionDeviceTypes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetVpnConnectionDeviceTypes_Call) RunAndReturn(run func(context.Context, *ec2.GetVpnConnectionDeviceTypesInput, ...func(*ec2.Options)) (*ec2.GetVpnConnectionDeviceTypesOutput, error)) *EC2_GetVpnConnectionDeviceTypes_Call {
	_c.Call.Return(run)
	return _c
}

// GetVpnTunnelReplacementStatus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) GetVpnTunnelReplacementStatus(ctx context.Context, params *ec2.GetVpnTunnelReplacementStatusInput, optFns ...func(*ec2.Options)) (*ec2.GetVpnTunnelReplacementStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetVpnTunnelReplacementStatus")
	}

	var r0 *ec2.GetVpnTunnelReplacementStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpnTunnelReplacementStatusInput, ...func(*ec2.Options)) (*ec2.GetVpnTunnelReplacementStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.GetVpnTunnelReplacementStatusInput, ...func(*ec2.Options)) *ec2.GetVpnTunnelReplacementStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.GetVpnTunnelReplacementStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.GetVpnTunnelReplacementStatusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_GetVpnTunnelReplacementStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVpnTunnelReplacementStatus'
type EC2_GetVpnTunnelReplacementStatus_Call struct {
	*mock.Call
}

// GetVpnTunnelReplacementStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.GetVpnTunnelReplacementStatusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) GetVpnTunnelReplacementStatus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_GetVpnTunnelReplacementStatus_Call {
	return &EC2_GetVpnTunnelReplacementStatus_Call{Call: _e.mock.On("GetVpnTunnelReplacementStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_GetVpnTunnelReplacementStatus_Call) Run(run func(ctx context.Context, params *ec2.GetVpnTunnelReplacementStatusInput, optFns ...func(*ec2.Options))) *EC2_GetVpnTunnelReplacementStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.GetVpnTunnelReplacementStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_GetVpnTunnelReplacementStatus_Call) Return(_a0 *ec2.GetVpnTunnelReplacementStatusOutput, _a1 error) *EC2_GetVpnTunnelReplacementStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_GetVpnTunnelReplacementStatus_Call) RunAndReturn(run func(context.Context, *ec2.GetVpnTunnelReplacementStatusInput, ...func(*ec2.Options)) (*ec2.GetVpnTunnelReplacementStatusOutput, error)) *EC2_GetVpnTunnelReplacementStatus_Call {
	_c.Call.Return(run)
	return _c
}

// ImportClientVpnClientCertificateRevocationList provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ImportClientVpnClientCertificateRevocationList(ctx context.Context, params *ec2.ImportClientVpnClientCertificateRevocationListInput, optFns ...func(*ec2.Options)) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ImportClientVpnClientCertificateRevocationList")
	}

	var r0 *ec2.ImportClientVpnClientCertificateRevocationListOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportClientVpnClientCertificateRevocationListInput, ...func(*ec2.Options)) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportClientVpnClientCertificateRevocationListInput, ...func(*ec2.Options)) *ec2.ImportClientVpnClientCertificateRevocationListOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportClientVpnClientCertificateRevocationListInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ImportClientVpnClientCertificateRevocationList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportClientVpnClientCertificateRevocationList'
type EC2_ImportClientVpnClientCertificateRevocationList_Call struct {
	*mock.Call
}

// ImportClientVpnClientCertificateRevocationList is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ImportClientVpnClientCertificateRevocationListInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ImportClientVpnClientCertificateRevocationList(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ImportClientVpnClientCertificateRevocationList_Call {
	return &EC2_ImportClientVpnClientCertificateRevocationList_Call{Call: _e.mock.On("ImportClientVpnClientCertificateRevocationList",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ImportClientVpnClientCertificateRevocationList_Call) Run(run func(ctx context.Context, params *ec2.ImportClientVpnClientCertificateRevocationListInput, optFns ...func(*ec2.Options))) *EC2_ImportClientVpnClientCertificateRevocationList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ImportClientVpnClientCertificateRevocationListInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ImportClientVpnClientCertificateRevocationList_Call) Return(_a0 *ec2.ImportClientVpnClientCertificateRevocationListOutput, _a1 error) *EC2_ImportClientVpnClientCertificateRevocationList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ImportClientVpnClientCertificateRevocationList_Call) RunAndReturn(run func(context.Context, *ec2.ImportClientVpnClientCertificateRevocationListInput, ...func(*ec2.Options)) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error)) *EC2_ImportClientVpnClientCertificateRevocationList_Call {
	_c.Call.Return(run)
	return _c
}

// ImportImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ImportImage(ctx context.Context, params *ec2.ImportImageInput, optFns ...func(*ec2.Options)) (*ec2.ImportImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ImportImage")
	}

	var r0 *ec2.ImportImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportImageInput, ...func(*ec2.Options)) (*ec2.ImportImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportImageInput, ...func(*ec2.Options)) *ec2.ImportImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ImportImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportImage'
type EC2_ImportImage_Call struct {
	*mock.Call
}

// ImportImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ImportImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ImportImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ImportImage_Call {
	return &EC2_ImportImage_Call{Call: _e.mock.On("ImportImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ImportImage_Call) Run(run func(ctx context.Context, params *ec2.ImportImageInput, optFns ...func(*ec2.Options))) *EC2_ImportImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ImportImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ImportImage_Call) Return(_a0 *ec2.ImportImageOutput, _a1 error) *EC2_ImportImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ImportImage_Call) RunAndReturn(run func(context.Context, *ec2.ImportImageInput, ...func(*ec2.Options)) (*ec2.ImportImageOutput, error)) *EC2_ImportImage_Call {
	_c.Call.Return(run)
	return _c
}

// ImportInstance provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ImportInstance(ctx context.Context, params *ec2.ImportInstanceInput, optFns ...func(*ec2.Options)) (*ec2.ImportInstanceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ImportInstance")
	}

	var r0 *ec2.ImportInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportInstanceInput, ...func(*ec2.Options)) (*ec2.ImportInstanceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportInstanceInput, ...func(*ec2.Options)) *ec2.ImportInstanceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportInstanceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportInstanceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ImportInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportInstance'
type EC2_ImportInstance_Call struct {
	*mock.Call
}

// ImportInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ImportInstanceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ImportInstance(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ImportInstance_Call {
	return &EC2_ImportInstance_Call{Call: _e.mock.On("ImportInstance",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ImportInstance_Call) Run(run func(ctx context.Context, params *ec2.ImportInstanceInput, optFns ...func(*ec2.Options))) *EC2_ImportInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ImportInstanceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ImportInstance_Call) Return(_a0 *ec2.ImportInstanceOutput, _a1 error) *EC2_ImportInstance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ImportInstance_Call) RunAndReturn(run func(context.Context, *ec2.ImportInstanceInput, ...func(*ec2.Options)) (*ec2.ImportInstanceOutput, error)) *EC2_ImportInstance_Call {
	_c.Call.Return(run)
	return _c
}

// ImportKeyPair provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ImportKeyPair(ctx context.Context, params *ec2.ImportKeyPairInput, optFns ...func(*ec2.Options)) (*ec2.ImportKeyPairOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ImportKeyPair")
	}

	var r0 *ec2.ImportKeyPairOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportKeyPairInput, ...func(*ec2.Options)) (*ec2.ImportKeyPairOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportKeyPairInput, ...func(*ec2.Options)) *ec2.ImportKeyPairOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportKeyPairOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportKeyPairInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ImportKeyPair_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportKeyPair'
type EC2_ImportKeyPair_Call struct {
	*mock.Call
}

// ImportKeyPair is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ImportKeyPairInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ImportKeyPair(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ImportKeyPair_Call {
	return &EC2_ImportKeyPair_Call{Call: _e.mock.On("ImportKeyPair",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ImportKeyPair_Call) Run(run func(ctx context.Context, params *ec2.ImportKeyPairInput, optFns ...func(*ec2.Options))) *EC2_ImportKeyPair_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ImportKeyPairInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ImportKeyPair_Call) Return(_a0 *ec2.ImportKeyPairOutput, _a1 error) *EC2_ImportKeyPair_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ImportKeyPair_Call) RunAndReturn(run func(context.Context, *ec2.ImportKeyPairInput, ...func(*ec2.Options)) (*ec2.ImportKeyPairOutput, error)) *EC2_ImportKeyPair_Call {
	_c.Call.Return(run)
	return _c
}

// ImportSnapshot provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ImportSnapshot(ctx context.Context, params *ec2.ImportSnapshotInput, optFns ...func(*ec2.Options)) (*ec2.ImportSnapshotOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ImportSnapshot")
	}

	var r0 *ec2.ImportSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportSnapshotInput, ...func(*ec2.Options)) (*ec2.ImportSnapshotOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportSnapshotInput, ...func(*ec2.Options)) *ec2.ImportSnapshotOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportSnapshotOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportSnapshotInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ImportSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportSnapshot'
type EC2_ImportSnapshot_Call struct {
	*mock.Call
}

// ImportSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ImportSnapshotInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ImportSnapshot(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ImportSnapshot_Call {
	return &EC2_ImportSnapshot_Call{Call: _e.mock.On("ImportSnapshot",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ImportSnapshot_Call) Run(run func(ctx context.Context, params *ec2.ImportSnapshotInput, optFns ...func(*ec2.Options))) *EC2_ImportSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ImportSnapshotInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ImportSnapshot_Call) Return(_a0 *ec2.ImportSnapshotOutput, _a1 error) *EC2_ImportSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ImportSnapshot_Call) RunAndReturn(run func(context.Context, *ec2.ImportSnapshotInput, ...func(*ec2.Options)) (*ec2.ImportSnapshotOutput, error)) *EC2_ImportSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// ImportVolume provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ImportVolume(ctx context.Context, params *ec2.ImportVolumeInput, optFns ...func(*ec2.Options)) (*ec2.ImportVolumeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ImportVolume")
	}

	var r0 *ec2.ImportVolumeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportVolumeInput, ...func(*ec2.Options)) (*ec2.ImportVolumeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ImportVolumeInput, ...func(*ec2.Options)) *ec2.ImportVolumeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ImportVolumeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ImportVolumeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ImportVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportVolume'
type EC2_ImportVolume_Call struct {
	*mock.Call
}

// ImportVolume is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ImportVolumeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ImportVolume(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ImportVolume_Call {
	return &EC2_ImportVolume_Call{Call: _e.mock.On("ImportVolume",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ImportVolume_Call) Run(run func(ctx context.Context, params *ec2.ImportVolumeInput, optFns ...func(*ec2.Options))) *EC2_ImportVolume_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ImportVolumeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ImportVolume_Call) Return(_a0 *ec2.ImportVolumeOutput, _a1 error) *EC2_ImportVolume_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ImportVolume_Call) RunAndReturn(run func(context.Context, *ec2.ImportVolumeInput, ...func(*ec2.Options)) (*ec2.ImportVolumeOutput, error)) *EC2_ImportVolume_Call {
	_c.Call.Return(run)
	return _c
}

// ListImagesInRecycleBin provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ListImagesInRecycleBin(ctx context.Context, params *ec2.ListImagesInRecycleBinInput, optFns ...func(*ec2.Options)) (*ec2.ListImagesInRecycleBinOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListImagesInRecycleBin")
	}

	var r0 *ec2.ListImagesInRecycleBinOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ListImagesInRecycleBinInput, ...func(*ec2.Options)) (*ec2.ListImagesInRecycleBinOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ListImagesInRecycleBinInput, ...func(*ec2.Options)) *ec2.ListImagesInRecycleBinOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ListImagesInRecycleBinOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ListImagesInRecycleBinInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ListImagesInRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListImagesInRecycleBin'
type EC2_ListImagesInRecycleBin_Call struct {
	*mock.Call
}

// ListImagesInRecycleBin is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ListImagesInRecycleBinInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ListImagesInRecycleBin(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ListImagesInRecycleBin_Call {
	return &EC2_ListImagesInRecycleBin_Call{Call: _e.mock.On("ListImagesInRecycleBin",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ListImagesInRecycleBin_Call) Run(run func(ctx context.Context, params *ec2.ListImagesInRecycleBinInput, optFns ...func(*ec2.Options))) *EC2_ListImagesInRecycleBin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ListImagesInRecycleBinInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ListImagesInRecycleBin_Call) Return(_a0 *ec2.ListImagesInRecycleBinOutput, _a1 error) *EC2_ListImagesInRecycleBin_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ListImagesInRecycleBin_Call) RunAndReturn(run func(context.Context, *ec2.ListImagesInRecycleBinInput, ...func(*ec2.Options)) (*ec2.ListImagesInRecycleBinOutput, error)) *EC2_ListImagesInRecycleBin_Call {
	_c.Call.Return(run)
	return _c
}

// ListSnapshotsInRecycleBin provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ListSnapshotsInRecycleBin(ctx context.Context, params *ec2.ListSnapshotsInRecycleBinInput, optFns ...func(*ec2.Options)) (*ec2.ListSnapshotsInRecycleBinOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListSnapshotsInRecycleBin")
	}

	var r0 *ec2.ListSnapshotsInRecycleBinOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ListSnapshotsInRecycleBinInput, ...func(*ec2.Options)) (*ec2.ListSnapshotsInRecycleBinOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ListSnapshotsInRecycleBinInput, ...func(*ec2.Options)) *ec2.ListSnapshotsInRecycleBinOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ListSnapshotsInRecycleBinOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ListSnapshotsInRecycleBinInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ListSnapshotsInRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSnapshotsInRecycleBin'
type EC2_ListSnapshotsInRecycleBin_Call struct {
	*mock.Call
}

// ListSnapshotsInRecycleBin is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ListSnapshotsInRecycleBinInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ListSnapshotsInRecycleBin(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ListSnapshotsInRecycleBin_Call {
	return &EC2_ListSnapshotsInRecycleBin_Call{Call: _e.mock.On("ListSnapshotsInRecycleBin",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ListSnapshotsInRecycleBin_Call) Run(run func(ctx context.Context, params *ec2.ListSnapshotsInRecycleBinInput, optFns ...func(*ec2.Options))) *EC2_ListSnapshotsInRecycleBin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ListSnapshotsInRecycleBinInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ListSnapshotsInRecycleBin_Call) Return(_a0 *ec2.ListSnapshotsInRecycleBinOutput, _a1 error) *EC2_ListSnapshotsInRecycleBin_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ListSnapshotsInRecycleBin_Call) RunAndReturn(run func(context.Context, *ec2.ListSnapshotsInRecycleBinInput, ...func(*ec2.Options)) (*ec2.ListSnapshotsInRecycleBinOutput, error)) *EC2_ListSnapshotsInRecycleBin_Call {
	_c.Call.Return(run)
	return _c
}

// ListVolumesInRecycleBin provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ListVolumesInRecycleBin(ctx context.Context, params *ec2.ListVolumesInRecycleBinInput, optFns ...func(*ec2.Options)) (*ec2.ListVolumesInRecycleBinOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListVolumesInRecycleBin")
	}

	var r0 *ec2.ListVolumesInRecycleBinOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ListVolumesInRecycleBinInput, ...func(*ec2.Options)) (*ec2.ListVolumesInRecycleBinOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ListVolumesInRecycleBinInput, ...func(*ec2.Options)) *ec2.ListVolumesInRecycleBinOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ListVolumesInRecycleBinOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ListVolumesInRecycleBinInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ListVolumesInRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumesInRecycleBin'
type EC2_ListVolumesInRecycleBin_Call struct {
	*mock.Call
}

// ListVolumesInRecycleBin is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ListVolumesInRecycleBinInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ListVolumesInRecycleBin(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ListVolumesInRecycleBin_Call {
	return &EC2_ListVolumesInRecycleBin_Call{Call: _e.mock.On("ListVolumesInRecycleBin",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ListVolumesInRecycleBin_Call) Run(run func(ctx context.Context, params *ec2.ListVolumesInRecycleBinInput, optFns ...func(*ec2.Options))) *EC2_ListVolumesInRecycleBin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ListVolumesInRecycleBinInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ListVolumesInRecycleBin_Call) Return(_a0 *ec2.ListVolumesInRecycleBinOutput, _a1 error) *EC2_ListVolumesInRecycleBin_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ListVolumesInRecycleBin_Call) RunAndReturn(run func(context.Context, *ec2.ListVolumesInRecycleBinInput, ...func(*ec2.Options)) (*ec2.ListVolumesInRecycleBinOutput, error)) *EC2_ListVolumesInRecycleBin_Call {
	_c.Call.Return(run)
	return _c
}

// LockSnapshot provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) LockSnapshot(ctx context.Context, params *ec2.LockSnapshotInput, optFns ...func(*ec2.Options)) (*ec2.LockSnapshotOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for LockSnapshot")
	}

	var r0 *ec2.LockSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.LockSnapshotInput, ...func(*ec2.Options)) (*ec2.LockSnapshotOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.LockSnapshotInput, ...func(*ec2.Options)) *ec2.LockSnapshotOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.LockSnapshotOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.LockSnapshotInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_LockSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LockSnapshot'
type EC2_LockSnapshot_Call struct {
	*mock.Call
}

// LockSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.LockSnapshotInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) LockSnapshot(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_LockSnapshot_Call {
	return &EC2_LockSnapshot_Call{Call: _e.mock.On("LockSnapshot",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_LockSnapshot_Call) Run(run func(ctx context.Context, params *ec2.LockSnapshotInput, optFns ...func(*ec2.Options))) *EC2_LockSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.LockSnapshotInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_LockSnapshot_Call) Return(_a0 *ec2.LockSnapshotOutput, _a1 error) *EC2_LockSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_LockSnapshot_Call) RunAndReturn(run func(context.Context, *ec2.LockSnapshotInput, ...func(*ec2.Options)) (*ec2.LockSnapshotOutput, error)) *EC2_LockSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyAddressAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyAddressAttribute(ctx context.Context, params *ec2.ModifyAddressAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyAddressAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyAddressAttribute")
	}

	var r0 *ec2.ModifyAddressAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyAddressAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyAddressAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyAddressAttributeInput, ...func(*ec2.Options)) *ec2.ModifyAddressAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyAddressAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyAddressAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyAddressAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyAddressAttribute'
type EC2_ModifyAddressAttribute_Call struct {
	*mock.Call
}

// ModifyAddressAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyAddressAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyAddressAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyAddressAttribute_Call {
	return &EC2_ModifyAddressAttribute_Call{Call: _e.mock.On("ModifyAddressAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyAddressAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifyAddressAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifyAddressAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyAddressAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyAddressAttribute_Call) Return(_a0 *ec2.ModifyAddressAttributeOutput, _a1 error) *EC2_ModifyAddressAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyAddressAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifyAddressAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyAddressAttributeOutput, error)) *EC2_ModifyAddressAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyAvailabilityZoneGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyAvailabilityZoneGroup(ctx context.Context, params *ec2.ModifyAvailabilityZoneGroupInput, optFns ...func(*ec2.Options)) (*ec2.ModifyAvailabilityZoneGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyAvailabilityZoneGroup")
	}

	var r0 *ec2.ModifyAvailabilityZoneGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyAvailabilityZoneGroupInput, ...func(*ec2.Options)) (*ec2.ModifyAvailabilityZoneGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyAvailabilityZoneGroupInput, ...func(*ec2.Options)) *ec2.ModifyAvailabilityZoneGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyAvailabilityZoneGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyAvailabilityZoneGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyAvailabilityZoneGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyAvailabilityZoneGroup'
type EC2_ModifyAvailabilityZoneGroup_Call struct {
	*mock.Call
}

// ModifyAvailabilityZoneGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyAvailabilityZoneGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyAvailabilityZoneGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyAvailabilityZoneGroup_Call {
	return &EC2_ModifyAvailabilityZoneGroup_Call{Call: _e.mock.On("ModifyAvailabilityZoneGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyAvailabilityZoneGroup_Call) Run(run func(ctx context.Context, params *ec2.ModifyAvailabilityZoneGroupInput, optFns ...func(*ec2.Options))) *EC2_ModifyAvailabilityZoneGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyAvailabilityZoneGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyAvailabilityZoneGroup_Call) Return(_a0 *ec2.ModifyAvailabilityZoneGroupOutput, _a1 error) *EC2_ModifyAvailabilityZoneGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyAvailabilityZoneGroup_Call) RunAndReturn(run func(context.Context, *ec2.ModifyAvailabilityZoneGroupInput, ...func(*ec2.Options)) (*ec2.ModifyAvailabilityZoneGroupOutput, error)) *EC2_ModifyAvailabilityZoneGroup_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyCapacityReservation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyCapacityReservation(ctx context.Context, params *ec2.ModifyCapacityReservationInput, optFns ...func(*ec2.Options)) (*ec2.ModifyCapacityReservationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyCapacityReservation")
	}

	var r0 *ec2.ModifyCapacityReservationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyCapacityReservationInput, ...func(*ec2.Options)) (*ec2.ModifyCapacityReservationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyCapacityReservationInput, ...func(*ec2.Options)) *ec2.ModifyCapacityReservationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyCapacityReservationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyCapacityReservationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyCapacityReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyCapacityReservation'
type EC2_ModifyCapacityReservation_Call struct {
	*mock.Call
}

// ModifyCapacityReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyCapacityReservationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyCapacityReservation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyCapacityReservation_Call {
	return &EC2_ModifyCapacityReservation_Call{Call: _e.mock.On("ModifyCapacityReservation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyCapacityReservation_Call) Run(run func(ctx context.Context, params *ec2.ModifyCapacityReservationInput, optFns ...func(*ec2.Options))) *EC2_ModifyCapacityReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyCapacityReservationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyCapacityReservation_Call) Return(_a0 *ec2.ModifyCapacityReservationOutput, _a1 error) *EC2_ModifyCapacityReservation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyCapacityReservation_Call) RunAndReturn(run func(context.Context, *ec2.ModifyCapacityReservationInput, ...func(*ec2.Options)) (*ec2.ModifyCapacityReservationOutput, error)) *EC2_ModifyCapacityReservation_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyCapacityReservationFleet provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyCapacityReservationFleet(ctx context.Context, params *ec2.ModifyCapacityReservationFleetInput, optFns ...func(*ec2.Options)) (*ec2.ModifyCapacityReservationFleetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyCapacityReservationFleet")
	}

	var r0 *ec2.ModifyCapacityReservationFleetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyCapacityReservationFleetInput, ...func(*ec2.Options)) (*ec2.ModifyCapacityReservationFleetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyCapacityReservationFleetInput, ...func(*ec2.Options)) *ec2.ModifyCapacityReservationFleetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyCapacityReservationFleetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyCapacityReservationFleetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyCapacityReservationFleet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyCapacityReservationFleet'
type EC2_ModifyCapacityReservationFleet_Call struct {
	*mock.Call
}

// ModifyCapacityReservationFleet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyCapacityReservationFleetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyCapacityReservationFleet(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyCapacityReservationFleet_Call {
	return &EC2_ModifyCapacityReservationFleet_Call{Call: _e.mock.On("ModifyCapacityReservationFleet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyCapacityReservationFleet_Call) Run(run func(ctx context.Context, params *ec2.ModifyCapacityReservationFleetInput, optFns ...func(*ec2.Options))) *EC2_ModifyCapacityReservationFleet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyCapacityReservationFleetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyCapacityReservationFleet_Call) Return(_a0 *ec2.ModifyCapacityReservationFleetOutput, _a1 error) *EC2_ModifyCapacityReservationFleet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyCapacityReservationFleet_Call) RunAndReturn(run func(context.Context, *ec2.ModifyCapacityReservationFleetInput, ...func(*ec2.Options)) (*ec2.ModifyCapacityReservationFleetOutput, error)) *EC2_ModifyCapacityReservationFleet_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyClientVpnEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyClientVpnEndpoint(ctx context.Context, params *ec2.ModifyClientVpnEndpointInput, optFns ...func(*ec2.Options)) (*ec2.ModifyClientVpnEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyClientVpnEndpoint")
	}

	var r0 *ec2.ModifyClientVpnEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyClientVpnEndpointInput, ...func(*ec2.Options)) (*ec2.ModifyClientVpnEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyClientVpnEndpointInput, ...func(*ec2.Options)) *ec2.ModifyClientVpnEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyClientVpnEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyClientVpnEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyClientVpnEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyClientVpnEndpoint'
type EC2_ModifyClientVpnEndpoint_Call struct {
	*mock.Call
}

// ModifyClientVpnEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyClientVpnEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyClientVpnEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyClientVpnEndpoint_Call {
	return &EC2_ModifyClientVpnEndpoint_Call{Call: _e.mock.On("ModifyClientVpnEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyClientVpnEndpoint_Call) Run(run func(ctx context.Context, params *ec2.ModifyClientVpnEndpointInput, optFns ...func(*ec2.Options))) *EC2_ModifyClientVpnEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyClientVpnEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyClientVpnEndpoint_Call) Return(_a0 *ec2.ModifyClientVpnEndpointOutput, _a1 error) *EC2_ModifyClientVpnEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyClientVpnEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.ModifyClientVpnEndpointInput, ...func(*ec2.Options)) (*ec2.ModifyClientVpnEndpointOutput, error)) *EC2_ModifyClientVpnEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyDefaultCreditSpecification provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyDefaultCreditSpecification(ctx context.Context, params *ec2.ModifyDefaultCreditSpecificationInput, optFns ...func(*ec2.Options)) (*ec2.ModifyDefaultCreditSpecificationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyDefaultCreditSpecification")
	}

	var r0 *ec2.ModifyDefaultCreditSpecificationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyDefaultCreditSpecificationInput, ...func(*ec2.Options)) (*ec2.ModifyDefaultCreditSpecificationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyDefaultCreditSpecificationInput, ...func(*ec2.Options)) *ec2.ModifyDefaultCreditSpecificationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyDefaultCreditSpecificationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyDefaultCreditSpecificationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyDefaultCreditSpecification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyDefaultCreditSpecification'
type EC2_ModifyDefaultCreditSpecification_Call struct {
	*mock.Call
}

// ModifyDefaultCreditSpecification is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyDefaultCreditSpecificationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyDefaultCreditSpecification(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyDefaultCreditSpecification_Call {
	return &EC2_ModifyDefaultCreditSpecification_Call{Call: _e.mock.On("ModifyDefaultCreditSpecification",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyDefaultCreditSpecification_Call) Run(run func(ctx context.Context, params *ec2.ModifyDefaultCreditSpecificationInput, optFns ...func(*ec2.Options))) *EC2_ModifyDefaultCreditSpecification_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyDefaultCreditSpecificationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyDefaultCreditSpecification_Call) Return(_a0 *ec2.ModifyDefaultCreditSpecificationOutput, _a1 error) *EC2_ModifyDefaultCreditSpecification_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyDefaultCreditSpecification_Call) RunAndReturn(run func(context.Context, *ec2.ModifyDefaultCreditSpecificationInput, ...func(*ec2.Options)) (*ec2.ModifyDefaultCreditSpecificationOutput, error)) *EC2_ModifyDefaultCreditSpecification_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyEbsDefaultKmsKeyId provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyEbsDefaultKmsKeyId(ctx context.Context, params *ec2.ModifyEbsDefaultKmsKeyIdInput, optFns ...func(*ec2.Options)) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyEbsDefaultKmsKeyId")
	}

	var r0 *ec2.ModifyEbsDefaultKmsKeyIdOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) *ec2.ModifyEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyEbsDefaultKmsKeyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyEbsDefaultKmsKeyId'
type EC2_ModifyEbsDefaultKmsKeyId_Call struct {
	*mock.Call
}

// ModifyEbsDefaultKmsKeyId is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyEbsDefaultKmsKeyIdInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyEbsDefaultKmsKeyId(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyEbsDefaultKmsKeyId_Call {
	return &EC2_ModifyEbsDefaultKmsKeyId_Call{Call: _e.mock.On("ModifyEbsDefaultKmsKeyId",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyEbsDefaultKmsKeyId_Call) Run(run func(ctx context.Context, params *ec2.ModifyEbsDefaultKmsKeyIdInput, optFns ...func(*ec2.Options))) *EC2_ModifyEbsDefaultKmsKeyId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyEbsDefaultKmsKeyIdInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyEbsDefaultKmsKeyId_Call) Return(_a0 *ec2.ModifyEbsDefaultKmsKeyIdOutput, _a1 error) *EC2_ModifyEbsDefaultKmsKeyId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyEbsDefaultKmsKeyId_Call) RunAndReturn(run func(context.Context, *ec2.ModifyEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error)) *EC2_ModifyEbsDefaultKmsKeyId_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyFleet provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyFleet(ctx context.Context, params *ec2.ModifyFleetInput, optFns ...func(*ec2.Options)) (*ec2.ModifyFleetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyFleet")
	}

	var r0 *ec2.ModifyFleetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyFleetInput, ...func(*ec2.Options)) (*ec2.ModifyFleetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyFleetInput, ...func(*ec2.Options)) *ec2.ModifyFleetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyFleetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyFleetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyFleet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyFleet'
type EC2_ModifyFleet_Call struct {
	*mock.Call
}

// ModifyFleet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyFleetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyFleet(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyFleet_Call {
	return &EC2_ModifyFleet_Call{Call: _e.mock.On("ModifyFleet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyFleet_Call) Run(run func(ctx context.Context, params *ec2.ModifyFleetInput, optFns ...func(*ec2.Options))) *EC2_ModifyFleet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyFleetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyFleet_Call) Return(_a0 *ec2.ModifyFleetOutput, _a1 error) *EC2_ModifyFleet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyFleet_Call) RunAndReturn(run func(context.Context, *ec2.ModifyFleetInput, ...func(*ec2.Options)) (*ec2.ModifyFleetOutput, error)) *EC2_ModifyFleet_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyFpgaImageAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyFpgaImageAttribute(ctx context.Context, params *ec2.ModifyFpgaImageAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyFpgaImageAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyFpgaImageAttribute")
	}

	var r0 *ec2.ModifyFpgaImageAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyFpgaImageAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyFpgaImageAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyFpgaImageAttributeInput, ...func(*ec2.Options)) *ec2.ModifyFpgaImageAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyFpgaImageAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyFpgaImageAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyFpgaImageAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyFpgaImageAttribute'
type EC2_ModifyFpgaImageAttribute_Call struct {
	*mock.Call
}

// ModifyFpgaImageAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyFpgaImageAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyFpgaImageAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyFpgaImageAttribute_Call {
	return &EC2_ModifyFpgaImageAttribute_Call{Call: _e.mock.On("ModifyFpgaImageAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyFpgaImageAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifyFpgaImageAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifyFpgaImageAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyFpgaImageAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyFpgaImageAttribute_Call) Return(_a0 *ec2.ModifyFpgaImageAttributeOutput, _a1 error) *EC2_ModifyFpgaImageAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyFpgaImageAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifyFpgaImageAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyFpgaImageAttributeOutput, error)) *EC2_ModifyFpgaImageAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyHosts provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyHosts(ctx context.Context, params *ec2.ModifyHostsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyHostsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyHosts")
	}

	var r0 *ec2.ModifyHostsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyHostsInput, ...func(*ec2.Options)) (*ec2.ModifyHostsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyHostsInput, ...func(*ec2.Options)) *ec2.ModifyHostsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyHostsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyHostsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyHosts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyHosts'
type EC2_ModifyHosts_Call struct {
	*mock.Call
}

// ModifyHosts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyHostsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyHosts(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyHosts_Call {
	return &EC2_ModifyHosts_Call{Call: _e.mock.On("ModifyHosts",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyHosts_Call) Run(run func(ctx context.Context, params *ec2.ModifyHostsInput, optFns ...func(*ec2.Options))) *EC2_ModifyHosts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyHostsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyHosts_Call) Return(_a0 *ec2.ModifyHostsOutput, _a1 error) *EC2_ModifyHosts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyHosts_Call) RunAndReturn(run func(context.Context, *ec2.ModifyHostsInput, ...func(*ec2.Options)) (*ec2.ModifyHostsOutput, error)) *EC2_ModifyHosts_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIdFormat provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIdFormat(ctx context.Context, params *ec2.ModifyIdFormatInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIdFormatOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIdFormat")
	}

	var r0 *ec2.ModifyIdFormatOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIdFormatInput, ...func(*ec2.Options)) (*ec2.ModifyIdFormatOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIdFormatInput, ...func(*ec2.Options)) *ec2.ModifyIdFormatOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIdFormatOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIdFormatInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIdFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIdFormat'
type EC2_ModifyIdFormat_Call struct {
	*mock.Call
}

// ModifyIdFormat is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIdFormatInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIdFormat(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIdFormat_Call {
	return &EC2_ModifyIdFormat_Call{Call: _e.mock.On("ModifyIdFormat",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIdFormat_Call) Run(run func(ctx context.Context, params *ec2.ModifyIdFormatInput, optFns ...func(*ec2.Options))) *EC2_ModifyIdFormat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIdFormatInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIdFormat_Call) Return(_a0 *ec2.ModifyIdFormatOutput, _a1 error) *EC2_ModifyIdFormat_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIdFormat_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIdFormatInput, ...func(*ec2.Options)) (*ec2.ModifyIdFormatOutput, error)) *EC2_ModifyIdFormat_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIdentityIdFormat provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIdentityIdFormat(ctx context.Context, params *ec2.ModifyIdentityIdFormatInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIdentityIdFormatOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIdentityIdFormat")
	}

	var r0 *ec2.ModifyIdentityIdFormatOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIdentityIdFormatInput, ...func(*ec2.Options)) (*ec2.ModifyIdentityIdFormatOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIdentityIdFormatInput, ...func(*ec2.Options)) *ec2.ModifyIdentityIdFormatOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIdentityIdFormatOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIdentityIdFormatInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIdentityIdFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIdentityIdFormat'
type EC2_ModifyIdentityIdFormat_Call struct {
	*mock.Call
}

// ModifyIdentityIdFormat is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIdentityIdFormatInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIdentityIdFormat(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIdentityIdFormat_Call {
	return &EC2_ModifyIdentityIdFormat_Call{Call: _e.mock.On("ModifyIdentityIdFormat",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIdentityIdFormat_Call) Run(run func(ctx context.Context, params *ec2.ModifyIdentityIdFormatInput, optFns ...func(*ec2.Options))) *EC2_ModifyIdentityIdFormat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIdentityIdFormatInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIdentityIdFormat_Call) Return(_a0 *ec2.ModifyIdentityIdFormatOutput, _a1 error) *EC2_ModifyIdentityIdFormat_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIdentityIdFormat_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIdentityIdFormatInput, ...func(*ec2.Options)) (*ec2.ModifyIdentityIdFormatOutput, error)) *EC2_ModifyIdentityIdFormat_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyImageAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyImageAttribute(ctx context.Context, params *ec2.ModifyImageAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyImageAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyImageAttribute")
	}

	var r0 *ec2.ModifyImageAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyImageAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyImageAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyImageAttributeInput, ...func(*ec2.Options)) *ec2.ModifyImageAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyImageAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyImageAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyImageAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyImageAttribute'
type EC2_ModifyImageAttribute_Call struct {
	*mock.Call
}

// ModifyImageAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyImageAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyImageAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyImageAttribute_Call {
	return &EC2_ModifyImageAttribute_Call{Call: _e.mock.On("ModifyImageAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyImageAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifyImageAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifyImageAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyImageAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyImageAttribute_Call) Return(_a0 *ec2.ModifyImageAttributeOutput, _a1 error) *EC2_ModifyImageAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyImageAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifyImageAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyImageAttributeOutput, error)) *EC2_ModifyImageAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceAttribute(ctx context.Context, params *ec2.ModifyInstanceAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceAttribute")
	}

	var r0 *ec2.ModifyInstanceAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceAttributeInput, ...func(*ec2.Options)) *ec2.ModifyInstanceAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceAttribute'
type EC2_ModifyInstanceAttribute_Call struct {
	*mock.Call
}

// ModifyInstanceAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceAttribute_Call {
	return &EC2_ModifyInstanceAttribute_Call{Call: _e.mock.On("ModifyInstanceAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceAttribute_Call) Return(_a0 *ec2.ModifyInstanceAttributeOutput, _a1 error) *EC2_ModifyInstanceAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceAttributeOutput, error)) *EC2_ModifyInstanceAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceCapacityReservationAttributes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceCapacityReservationAttributes(ctx context.Context, params *ec2.ModifyInstanceCapacityReservationAttributesInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceCapacityReservationAttributes")
	}

	var r0 *ec2.ModifyInstanceCapacityReservationAttributesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceCapacityReservationAttributesInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceCapacityReservationAttributesInput, ...func(*ec2.Options)) *ec2.ModifyInstanceCapacityReservationAttributesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceCapacityReservationAttributesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceCapacityReservationAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceCapacityReservationAttributes'
type EC2_ModifyInstanceCapacityReservationAttributes_Call struct {
	*mock.Call
}

// ModifyInstanceCapacityReservationAttributes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceCapacityReservationAttributesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceCapacityReservationAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceCapacityReservationAttributes_Call {
	return &EC2_ModifyInstanceCapacityReservationAttributes_Call{Call: _e.mock.On("ModifyInstanceCapacityReservationAttributes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceCapacityReservationAttributes_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceCapacityReservationAttributesInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceCapacityReservationAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceCapacityReservationAttributesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceCapacityReservationAttributes_Call) Return(_a0 *ec2.ModifyInstanceCapacityReservationAttributesOutput, _a1 error) *EC2_ModifyInstanceCapacityReservationAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceCapacityReservationAttributes_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceCapacityReservationAttributesInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error)) *EC2_ModifyInstanceCapacityReservationAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceConnectEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceConnectEndpoint(ctx context.Context, params *ec2.ModifyInstanceConnectEndpointInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceConnectEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceConnectEndpoint")
	}

	var r0 *ec2.ModifyInstanceConnectEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceConnectEndpointInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceConnectEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceConnectEndpointInput, ...func(*ec2.Options)) *ec2.ModifyInstanceConnectEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceConnectEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceConnectEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceConnectEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceConnectEndpoint'
type EC2_ModifyInstanceConnectEndpoint_Call struct {
	*mock.Call
}

// ModifyInstanceConnectEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceConnectEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceConnectEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceConnectEndpoint_Call {
	return &EC2_ModifyInstanceConnectEndpoint_Call{Call: _e.mock.On("ModifyInstanceConnectEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceConnectEndpoint_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceConnectEndpointInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceConnectEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceConnectEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceConnectEndpoint_Call) Return(_a0 *ec2.ModifyInstanceConnectEndpointOutput, _a1 error) *EC2_ModifyInstanceConnectEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceConnectEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceConnectEndpointInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceConnectEndpointOutput, error)) *EC2_ModifyInstanceConnectEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceCpuOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceCpuOptions(ctx context.Context, params *ec2.ModifyInstanceCpuOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceCpuOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceCpuOptions")
	}

	var r0 *ec2.ModifyInstanceCpuOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceCpuOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceCpuOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceCpuOptionsInput, ...func(*ec2.Options)) *ec2.ModifyInstanceCpuOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceCpuOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceCpuOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceCpuOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceCpuOptions'
type EC2_ModifyInstanceCpuOptions_Call struct {
	*mock.Call
}

// ModifyInstanceCpuOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceCpuOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceCpuOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceCpuOptions_Call {
	return &EC2_ModifyInstanceCpuOptions_Call{Call: _e.mock.On("ModifyInstanceCpuOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceCpuOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceCpuOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceCpuOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceCpuOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceCpuOptions_Call) Return(_a0 *ec2.ModifyInstanceCpuOptionsOutput, _a1 error) *EC2_ModifyInstanceCpuOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceCpuOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceCpuOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceCpuOptionsOutput, error)) *EC2_ModifyInstanceCpuOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceCreditSpecification provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceCreditSpecification(ctx context.Context, params *ec2.ModifyInstanceCreditSpecificationInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceCreditSpecificationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceCreditSpecification")
	}

	var r0 *ec2.ModifyInstanceCreditSpecificationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceCreditSpecificationInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceCreditSpecificationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceCreditSpecificationInput, ...func(*ec2.Options)) *ec2.ModifyInstanceCreditSpecificationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceCreditSpecificationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceCreditSpecificationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceCreditSpecification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceCreditSpecification'
type EC2_ModifyInstanceCreditSpecification_Call struct {
	*mock.Call
}

// ModifyInstanceCreditSpecification is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceCreditSpecificationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceCreditSpecification(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceCreditSpecification_Call {
	return &EC2_ModifyInstanceCreditSpecification_Call{Call: _e.mock.On("ModifyInstanceCreditSpecification",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceCreditSpecification_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceCreditSpecificationInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceCreditSpecification_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceCreditSpecificationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceCreditSpecification_Call) Return(_a0 *ec2.ModifyInstanceCreditSpecificationOutput, _a1 error) *EC2_ModifyInstanceCreditSpecification_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceCreditSpecification_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceCreditSpecificationInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceCreditSpecificationOutput, error)) *EC2_ModifyInstanceCreditSpecification_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceEventStartTime provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceEventStartTime(ctx context.Context, params *ec2.ModifyInstanceEventStartTimeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceEventStartTimeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceEventStartTime")
	}

	var r0 *ec2.ModifyInstanceEventStartTimeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceEventStartTimeInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceEventStartTimeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceEventStartTimeInput, ...func(*ec2.Options)) *ec2.ModifyInstanceEventStartTimeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceEventStartTimeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceEventStartTimeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceEventStartTime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceEventStartTime'
type EC2_ModifyInstanceEventStartTime_Call struct {
	*mock.Call
}

// ModifyInstanceEventStartTime is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceEventStartTimeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceEventStartTime(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceEventStartTime_Call {
	return &EC2_ModifyInstanceEventStartTime_Call{Call: _e.mock.On("ModifyInstanceEventStartTime",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceEventStartTime_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceEventStartTimeInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceEventStartTime_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceEventStartTimeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceEventStartTime_Call) Return(_a0 *ec2.ModifyInstanceEventStartTimeOutput, _a1 error) *EC2_ModifyInstanceEventStartTime_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceEventStartTime_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceEventStartTimeInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceEventStartTimeOutput, error)) *EC2_ModifyInstanceEventStartTime_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceEventWindow provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceEventWindow(ctx context.Context, params *ec2.ModifyInstanceEventWindowInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceEventWindowOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceEventWindow")
	}

	var r0 *ec2.ModifyInstanceEventWindowOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceEventWindowOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceEventWindowInput, ...func(*ec2.Options)) *ec2.ModifyInstanceEventWindowOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceEventWindowOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceEventWindowInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceEventWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceEventWindow'
type EC2_ModifyInstanceEventWindow_Call struct {
	*mock.Call
}

// ModifyInstanceEventWindow is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceEventWindowInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceEventWindow(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceEventWindow_Call {
	return &EC2_ModifyInstanceEventWindow_Call{Call: _e.mock.On("ModifyInstanceEventWindow",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceEventWindow_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceEventWindowInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceEventWindow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceEventWindowInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceEventWindow_Call) Return(_a0 *ec2.ModifyInstanceEventWindowOutput, _a1 error) *EC2_ModifyInstanceEventWindow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceEventWindow_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceEventWindowInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceEventWindowOutput, error)) *EC2_ModifyInstanceEventWindow_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceMaintenanceOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceMaintenanceOptions(ctx context.Context, params *ec2.ModifyInstanceMaintenanceOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceMaintenanceOptions")
	}

	var r0 *ec2.ModifyInstanceMaintenanceOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceMaintenanceOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceMaintenanceOptionsInput, ...func(*ec2.Options)) *ec2.ModifyInstanceMaintenanceOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceMaintenanceOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceMaintenanceOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceMaintenanceOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceMaintenanceOptions'
type EC2_ModifyInstanceMaintenanceOptions_Call struct {
	*mock.Call
}

// ModifyInstanceMaintenanceOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceMaintenanceOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceMaintenanceOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceMaintenanceOptions_Call {
	return &EC2_ModifyInstanceMaintenanceOptions_Call{Call: _e.mock.On("ModifyInstanceMaintenanceOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceMaintenanceOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceMaintenanceOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceMaintenanceOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceMaintenanceOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceMaintenanceOptions_Call) Return(_a0 *ec2.ModifyInstanceMaintenanceOptionsOutput, _a1 error) *EC2_ModifyInstanceMaintenanceOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceMaintenanceOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceMaintenanceOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error)) *EC2_ModifyInstanceMaintenanceOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceMetadataDefaults provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceMetadataDefaults(ctx context.Context, params *ec2.ModifyInstanceMetadataDefaultsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceMetadataDefaultsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceMetadataDefaults")
	}

	var r0 *ec2.ModifyInstanceMetadataDefaultsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceMetadataDefaultsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceMetadataDefaultsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceMetadataDefaultsInput, ...func(*ec2.Options)) *ec2.ModifyInstanceMetadataDefaultsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceMetadataDefaultsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceMetadataDefaultsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceMetadataDefaults_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceMetadataDefaults'
type EC2_ModifyInstanceMetadataDefaults_Call struct {
	*mock.Call
}

// ModifyInstanceMetadataDefaults is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceMetadataDefaultsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceMetadataDefaults(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceMetadataDefaults_Call {
	return &EC2_ModifyInstanceMetadataDefaults_Call{Call: _e.mock.On("ModifyInstanceMetadataDefaults",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceMetadataDefaults_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceMetadataDefaultsInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceMetadataDefaults_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceMetadataDefaultsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceMetadataDefaults_Call) Return(_a0 *ec2.ModifyInstanceMetadataDefaultsOutput, _a1 error) *EC2_ModifyInstanceMetadataDefaults_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceMetadataDefaults_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceMetadataDefaultsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceMetadataDefaultsOutput, error)) *EC2_ModifyInstanceMetadataDefaults_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceMetadataOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceMetadataOptions(ctx context.Context, params *ec2.ModifyInstanceMetadataOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceMetadataOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceMetadataOptions")
	}

	var r0 *ec2.ModifyInstanceMetadataOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceMetadataOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceMetadataOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceMetadataOptionsInput, ...func(*ec2.Options)) *ec2.ModifyInstanceMetadataOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceMetadataOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceMetadataOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceMetadataOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceMetadataOptions'
type EC2_ModifyInstanceMetadataOptions_Call struct {
	*mock.Call
}

// ModifyInstanceMetadataOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceMetadataOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceMetadataOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceMetadataOptions_Call {
	return &EC2_ModifyInstanceMetadataOptions_Call{Call: _e.mock.On("ModifyInstanceMetadataOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceMetadataOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceMetadataOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceMetadataOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceMetadataOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceMetadataOptions_Call) Return(_a0 *ec2.ModifyInstanceMetadataOptionsOutput, _a1 error) *EC2_ModifyInstanceMetadataOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceMetadataOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceMetadataOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceMetadataOptionsOutput, error)) *EC2_ModifyInstanceMetadataOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstanceNetworkPerformanceOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstanceNetworkPerformanceOptions(ctx context.Context, params *ec2.ModifyInstanceNetworkPerformanceOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstanceNetworkPerformanceOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstanceNetworkPerformanceOptions")
	}

	var r0 *ec2.ModifyInstanceNetworkPerformanceOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceNetworkPerformanceOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceNetworkPerformanceOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstanceNetworkPerformanceOptionsInput, ...func(*ec2.Options)) *ec2.ModifyInstanceNetworkPerformanceOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstanceNetworkPerformanceOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstanceNetworkPerformanceOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstanceNetworkPerformanceOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstanceNetworkPerformanceOptions'
type EC2_ModifyInstanceNetworkPerformanceOptions_Call struct {
	*mock.Call
}

// ModifyInstanceNetworkPerformanceOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstanceNetworkPerformanceOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstanceNetworkPerformanceOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstanceNetworkPerformanceOptions_Call {
	return &EC2_ModifyInstanceNetworkPerformanceOptions_Call{Call: _e.mock.On("ModifyInstanceNetworkPerformanceOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstanceNetworkPerformanceOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstanceNetworkPerformanceOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstanceNetworkPerformanceOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstanceNetworkPerformanceOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstanceNetworkPerformanceOptions_Call) Return(_a0 *ec2.ModifyInstanceNetworkPerformanceOptionsOutput, _a1 error) *EC2_ModifyInstanceNetworkPerformanceOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstanceNetworkPerformanceOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstanceNetworkPerformanceOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyInstanceNetworkPerformanceOptionsOutput, error)) *EC2_ModifyInstanceNetworkPerformanceOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyInstancePlacement provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyInstancePlacement(ctx context.Context, params *ec2.ModifyInstancePlacementInput, optFns ...func(*ec2.Options)) (*ec2.ModifyInstancePlacementOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyInstancePlacement")
	}

	var r0 *ec2.ModifyInstancePlacementOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstancePlacementInput, ...func(*ec2.Options)) (*ec2.ModifyInstancePlacementOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyInstancePlacementInput, ...func(*ec2.Options)) *ec2.ModifyInstancePlacementOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyInstancePlacementOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyInstancePlacementInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyInstancePlacement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyInstancePlacement'
type EC2_ModifyInstancePlacement_Call struct {
	*mock.Call
}

// ModifyInstancePlacement is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyInstancePlacementInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyInstancePlacement(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyInstancePlacement_Call {
	return &EC2_ModifyInstancePlacement_Call{Call: _e.mock.On("ModifyInstancePlacement",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyInstancePlacement_Call) Run(run func(ctx context.Context, params *ec2.ModifyInstancePlacementInput, optFns ...func(*ec2.Options))) *EC2_ModifyInstancePlacement_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyInstancePlacementInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyInstancePlacement_Call) Return(_a0 *ec2.ModifyInstancePlacementOutput, _a1 error) *EC2_ModifyInstancePlacement_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyInstancePlacement_Call) RunAndReturn(run func(context.Context, *ec2.ModifyInstancePlacementInput, ...func(*ec2.Options)) (*ec2.ModifyInstancePlacementOutput, error)) *EC2_ModifyInstancePlacement_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIpam provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIpam(ctx context.Context, params *ec2.ModifyIpamInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIpam")
	}

	var r0 *ec2.ModifyIpamOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamInput, ...func(*ec2.Options)) (*ec2.ModifyIpamOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamInput, ...func(*ec2.Options)) *ec2.ModifyIpamOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIpamOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIpam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpam'
type EC2_ModifyIpam_Call struct {
	*mock.Call
}

// ModifyIpam is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIpamInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIpam(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpam_Call {
	return &EC2_ModifyIpam_Call{Call: _e.mock.On("ModifyIpam",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIpam_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIpamInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIpam_Call) Return(_a0 *ec2.ModifyIpamOutput, _a1 error) *EC2_ModifyIpam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIpam_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamInput, ...func(*ec2.Options)) (*ec2.ModifyIpamOutput, error)) *EC2_ModifyIpam_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIpamPolicyAllocationRules provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIpamPolicyAllocationRules(ctx context.Context, params *ec2.ModifyIpamPolicyAllocationRulesInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamPolicyAllocationRulesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIpamPolicyAllocationRules")
	}

	var r0 *ec2.ModifyIpamPolicyAllocationRulesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPolicyAllocationRulesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) *ec2.ModifyIpamPolicyAllocationRulesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIpamPolicyAllocationRulesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIpamPolicyAllocationRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpamPolicyAllocationRules'
type EC2_ModifyIpamPolicyAllocationRules_Call struct {
	*mock.Call
}

// ModifyIpamPolicyAllocationRules is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIpamPolicyAllocationRulesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIpamPolicyAllocationRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpamPolicyAllocationRules_Call {
	return &EC2_ModifyIpamPolicyAllocationRules_Call{Call: _e.mock.On("ModifyIpamPolicyAllocationRules",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIpamPolicyAllocationRules_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamPolicyAllocationRulesInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpamPolicyAllocationRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIpamPolicyAllocationRulesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIpamPolicyAllocationRules_Call) Return(_a0 *ec2.ModifyIpamPolicyAllocationRulesOutput, _a1 error) *EC2_ModifyIpamPolicyAllocationRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIpamPolicyAllocationRules_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamPolicyAllocationRulesInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPolicyAllocationRulesOutput, error)) *EC2_ModifyIpamPolicyAllocationRules_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIpamPool provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIpamPool(ctx context.Context, params *ec2.ModifyIpamPoolInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamPoolOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIpamPool")
	}

	var r0 *ec2.ModifyIpamPoolOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPoolInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPoolOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPoolInput, ...func(*ec2.Options)) *ec2.ModifyIpamPoolOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIpamPoolOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamPoolInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIpamPool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpamPool'
type EC2_ModifyIpamPool_Call struct {
	*mock.Call
}

// ModifyIpamPool is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIpamPoolInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIpamPool(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpamPool_Call {
	return &EC2_ModifyIpamPool_Call{Call: _e.mock.On("ModifyIpamPool",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIpamPool_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamPoolInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpamPool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIpamPoolInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIpamPool_Call) Return(_a0 *ec2.ModifyIpamPoolOutput, _a1 error) *EC2_ModifyIpamPool_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIpamPool_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamPoolInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPoolOutput, error)) *EC2_ModifyIpamPool_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIpamPrefixListResolver provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIpamPrefixListResolver(ctx context.Context, params *ec2.ModifyIpamPrefixListResolverInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamPrefixListResolverOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIpamPrefixListResolver")
	}

	var r0 *ec2.ModifyIpamPrefixListResolverOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPrefixListResolverInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPrefixListResolverOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPrefixListResolverInput, ...func(*ec2.Options)) *ec2.ModifyIpamPrefixListResolverOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIpamPrefixListResolverOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamPrefixListResolverInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIpamPrefixListResolver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpamPrefixListResolver'
type EC2_ModifyIpamPrefixListResolver_Call struct {
	*mock.Call
}

// ModifyIpamPrefixListResolver is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIpamPrefixListResolverInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIpamPrefixListResolver(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpamPrefixListResolver_Call {
	return &EC2_ModifyIpamPrefixListResolver_Call{Call: _e.mock.On("ModifyIpamPrefixListResolver",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIpamPrefixListResolver_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamPrefixListResolverInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpamPrefixListResolver_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIpamPrefixListResolverInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIpamPrefixListResolver_Call) Return(_a0 *ec2.ModifyIpamPrefixListResolverOutput, _a1 error) *EC2_ModifyIpamPrefixListResolver_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIpamPrefixListResolver_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamPrefixListResolverInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPrefixListResolverOutput, error)) *EC2_ModifyIpamPrefixListResolver_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIpamPrefixListResolverTarget provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIpamPrefixListResolverTarget(ctx context.Context, params *ec2.ModifyIpamPrefixListResolverTargetInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamPrefixListResolverTargetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIpamPrefixListResolverTarget")
	}

	var r0 *ec2.ModifyIpamPrefixListResolverTargetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPrefixListResolverTargetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) *ec2.ModifyIpamPrefixListResolverTargetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIpamPrefixListResolverTargetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIpamPrefixListResolverTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpamPrefixListResolverTarget'
type EC2_ModifyIpamPrefixListResolverTarget_Call struct {
	*mock.Call
}

// ModifyIpamPrefixListResolverTarget is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIpamPrefixListResolverTargetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIpamPrefixListResolverTarget(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpamPrefixListResolverTarget_Call {
	return &EC2_ModifyIpamPrefixListResolverTarget_Call{Call: _e.mock.On("ModifyIpamPrefixListResolverTarget",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIpamPrefixListResolverTarget_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamPrefixListResolverTargetInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpamPrefixListResolverTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIpamPrefixListResolverTargetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIpamPrefixListResolverTarget_Call) Return(_a0 *ec2.ModifyIpamPrefixListResolverTargetOutput, _a1 error) *EC2_ModifyIpamPrefixListResolverTarget_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIpamPrefixListResolverTarget_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamPrefixListResolverTargetInput, ...func(*ec2.Options)) (*ec2.ModifyIpamPrefixListResolverTargetOutput, error)) *EC2_ModifyIpamPrefixListResolverTarget_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIpamResourceCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIpamResourceCidr(ctx context.Context, params *ec2.ModifyIpamResourceCidrInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamResourceCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIpamResourceCidr")
	}

	var r0 *ec2.ModifyIpamResourceCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamResourceCidrInput, ...func(*ec2.Options)) (*ec2.ModifyIpamResourceCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamResourceCidrInput, ...func(*ec2.Options)) *ec2.ModifyIpamResourceCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIpamResourceCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamResourceCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIpamResourceCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpamResourceCidr'
type EC2_ModifyIpamResourceCidr_Call struct {
	*mock.Call
}

// ModifyIpamResourceCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIpamResourceCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIpamResourceCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpamResourceCidr_Call {
	return &EC2_ModifyIpamResourceCidr_Call{Call: _e.mock.On("ModifyIpamResourceCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIpamResourceCidr_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamResourceCidrInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpamResourceCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIpamResourceCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIpamResourceCidr_Call) Return(_a0 *ec2.ModifyIpamResourceCidrOutput, _a1 error) *EC2_ModifyIpamResourceCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIpamResourceCidr_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamResourceCidrInput, ...func(*ec2.Options)) (*ec2.ModifyIpamResourceCidrOutput, error)) *EC2_ModifyIpamResourceCidr_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIpamResourceDiscovery provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIpamResourceDiscovery(ctx context.Context, params *ec2.ModifyIpamResourceDiscoveryInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamResourceDiscoveryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIpamResourceDiscovery")
	}

	var r0 *ec2.ModifyIpamResourceDiscoveryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.ModifyIpamResourceDiscoveryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamResourceDiscoveryInput, ...func(*ec2.Options)) *ec2.ModifyIpamResourceDiscoveryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIpamResourceDiscoveryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamResourceDiscoveryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIpamResourceDiscovery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpamResourceDiscovery'
type EC2_ModifyIpamResourceDiscovery_Call struct {
	*mock.Call
}

// ModifyIpamResourceDiscovery is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIpamResourceDiscoveryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIpamResourceDiscovery(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpamResourceDiscovery_Call {
	return &EC2_ModifyIpamResourceDiscovery_Call{Call: _e.mock.On("ModifyIpamResourceDiscovery",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIpamResourceDiscovery_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamResourceDiscoveryInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpamResourceDiscovery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIpamResourceDiscoveryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIpamResourceDiscovery_Call) Return(_a0 *ec2.ModifyIpamResourceDiscoveryOutput, _a1 error) *EC2_ModifyIpamResourceDiscovery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIpamResourceDiscovery_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamResourceDiscoveryInput, ...func(*ec2.Options)) (*ec2.ModifyIpamResourceDiscoveryOutput, error)) *EC2_ModifyIpamResourceDiscovery_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyIpamScope provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyIpamScope(ctx context.Context, params *ec2.ModifyIpamScopeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyIpamScopeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyIpamScope")
	}

	var r0 *ec2.ModifyIpamScopeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamScopeInput, ...func(*ec2.Options)) (*ec2.ModifyIpamScopeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyIpamScopeInput, ...func(*ec2.Options)) *ec2.ModifyIpamScopeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyIpamScopeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyIpamScopeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyIpamScope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyIpamScope'
type EC2_ModifyIpamScope_Call struct {
	*mock.Call
}

// ModifyIpamScope is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyIpamScopeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyIpamScope(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyIpamScope_Call {
	return &EC2_ModifyIpamScope_Call{Call: _e.mock.On("ModifyIpamScope",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyIpamScope_Call) Run(run func(ctx context.Context, params *ec2.ModifyIpamScopeInput, optFns ...func(*ec2.Options))) *EC2_ModifyIpamScope_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyIpamScopeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyIpamScope_Call) Return(_a0 *ec2.ModifyIpamScopeOutput, _a1 error) *EC2_ModifyIpamScope_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyIpamScope_Call) RunAndReturn(run func(context.Context, *ec2.ModifyIpamScopeInput, ...func(*ec2.Options)) (*ec2.ModifyIpamScopeOutput, error)) *EC2_ModifyIpamScope_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyLaunchTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyLaunchTemplate(ctx context.Context, params *ec2.ModifyLaunchTemplateInput, optFns ...func(*ec2.Options)) (*ec2.ModifyLaunchTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyLaunchTemplate")
	}

	var r0 *ec2.ModifyLaunchTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyLaunchTemplateInput, ...func(*ec2.Options)) (*ec2.ModifyLaunchTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyLaunchTemplateInput, ...func(*ec2.Options)) *ec2.ModifyLaunchTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyLaunchTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyLaunchTemplateInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyLaunchTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyLaunchTemplate'
type EC2_ModifyLaunchTemplate_Call struct {
	*mock.Call
}

// ModifyLaunchTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyLaunchTemplateInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyLaunchTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyLaunchTemplate_Call {
	return &EC2_ModifyLaunchTemplate_Call{Call: _e.mock.On("ModifyLaunchTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyLaunchTemplate_Call) Run(run func(ctx context.Context, params *ec2.ModifyLaunchTemplateInput, optFns ...func(*ec2.Options))) *EC2_ModifyLaunchTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyLaunchTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyLaunchTemplate_Call) Return(_a0 *ec2.ModifyLaunchTemplateOutput, _a1 error) *EC2_ModifyLaunchTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyLaunchTemplate_Call) RunAndReturn(run func(context.Context, *ec2.ModifyLaunchTemplateInput, ...func(*ec2.Options)) (*ec2.ModifyLaunchTemplateOutput, error)) *EC2_ModifyLaunchTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyLocalGatewayRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyLocalGatewayRoute(ctx context.Context, params *ec2.ModifyLocalGatewayRouteInput, optFns ...func(*ec2.Options)) (*ec2.ModifyLocalGatewayRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyLocalGatewayRoute")
	}

	var r0 *ec2.ModifyLocalGatewayRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyLocalGatewayRouteInput, ...func(*ec2.Options)) (*ec2.ModifyLocalGatewayRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyLocalGatewayRouteInput, ...func(*ec2.Options)) *ec2.ModifyLocalGatewayRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyLocalGatewayRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyLocalGatewayRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyLocalGatewayRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyLocalGatewayRoute'
type EC2_ModifyLocalGatewayRoute_Call struct {
	*mock.Call
}

// ModifyLocalGatewayRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyLocalGatewayRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyLocalGatewayRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyLocalGatewayRoute_Call {
	return &EC2_ModifyLocalGatewayRoute_Call{Call: _e.mock.On("ModifyLocalGatewayRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyLocalGatewayRoute_Call) Run(run func(ctx context.Context, params *ec2.ModifyLocalGatewayRouteInput, optFns ...func(*ec2.Options))) *EC2_ModifyLocalGatewayRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyLocalGatewayRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyLocalGatewayRoute_Call) Return(_a0 *ec2.ModifyLocalGatewayRouteOutput, _a1 error) *EC2_ModifyLocalGatewayRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyLocalGatewayRoute_Call) RunAndReturn(run func(context.Context, *ec2.ModifyLocalGatewayRouteInput, ...func(*ec2.Options)) (*ec2.ModifyLocalGatewayRouteOutput, error)) *EC2_ModifyLocalGatewayRoute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyManagedPrefixList provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyManagedPrefixList(ctx context.Context, params *ec2.ModifyManagedPrefixListInput, optFns ...func(*ec2.Options)) (*ec2.ModifyManagedPrefixListOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyManagedPrefixList")
	}

	var r0 *ec2.ModifyManagedPrefixListOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyManagedPrefixListInput, ...func(*ec2.Options)) (*ec2.ModifyManagedPrefixListOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyManagedPrefixListInput, ...func(*ec2.Options)) *ec2.ModifyManagedPrefixListOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyManagedPrefixListOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyManagedPrefixListInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyManagedPrefixList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyManagedPrefixList'
type EC2_ModifyManagedPrefixList_Call struct {
	*mock.Call
}

// ModifyManagedPrefixList is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyManagedPrefixListInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyManagedPrefixList(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyManagedPrefixList_Call {
	return &EC2_ModifyManagedPrefixList_Call{Call: _e.mock.On("ModifyManagedPrefixList",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyManagedPrefixList_Call) Run(run func(ctx context.Context, params *ec2.ModifyManagedPrefixListInput, optFns ...func(*ec2.Options))) *EC2_ModifyManagedPrefixList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyManagedPrefixListInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyManagedPrefixList_Call) Return(_a0 *ec2.ModifyManagedPrefixListOutput, _a1 error) *EC2_ModifyManagedPrefixList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyManagedPrefixList_Call) RunAndReturn(run func(context.Context, *ec2.ModifyManagedPrefixListInput, ...func(*ec2.Options)) (*ec2.ModifyManagedPrefixListOutput, error)) *EC2_ModifyManagedPrefixList_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyNetworkInterfaceAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyNetworkInterfaceAttribute(ctx context.Context, params *ec2.ModifyNetworkInterfaceAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyNetworkInterfaceAttribute")
	}

	var r0 *ec2.ModifyNetworkInterfaceAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyNetworkInterfaceAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyNetworkInterfaceAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyNetworkInterfaceAttributeInput, ...func(*ec2.Options)) *ec2.ModifyNetworkInterfaceAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyNetworkInterfaceAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyNetworkInterfaceAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyNetworkInterfaceAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyNetworkInterfaceAttribute'
type EC2_ModifyNetworkInterfaceAttribute_Call struct {
	*mock.Call
}

// ModifyNetworkInterfaceAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyNetworkInterfaceAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyNetworkInterfaceAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyNetworkInterfaceAttribute_Call {
	return &EC2_ModifyNetworkInterfaceAttribute_Call{Call: _e.mock.On("ModifyNetworkInterfaceAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyNetworkInterfaceAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifyNetworkInterfaceAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifyNetworkInterfaceAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyNetworkInterfaceAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyNetworkInterfaceAttribute_Call) Return(_a0 *ec2.ModifyNetworkInterfaceAttributeOutput, _a1 error) *EC2_ModifyNetworkInterfaceAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyNetworkInterfaceAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifyNetworkInterfaceAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyNetworkInterfaceAttributeOutput, error)) *EC2_ModifyNetworkInterfaceAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyPrivateDnsNameOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyPrivateDnsNameOptions(ctx context.Context, params *ec2.ModifyPrivateDnsNameOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyPrivateDnsNameOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyPrivateDnsNameOptions")
	}

	var r0 *ec2.ModifyPrivateDnsNameOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyPrivateDnsNameOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyPrivateDnsNameOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyPrivateDnsNameOptionsInput, ...func(*ec2.Options)) *ec2.ModifyPrivateDnsNameOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyPrivateDnsNameOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyPrivateDnsNameOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyPrivateDnsNameOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyPrivateDnsNameOptions'
type EC2_ModifyPrivateDnsNameOptions_Call struct {
	*mock.Call
}

// ModifyPrivateDnsNameOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyPrivateDnsNameOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyPrivateDnsNameOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyPrivateDnsNameOptions_Call {
	return &EC2_ModifyPrivateDnsNameOptions_Call{Call: _e.mock.On("ModifyPrivateDnsNameOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyPrivateDnsNameOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyPrivateDnsNameOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyPrivateDnsNameOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyPrivateDnsNameOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyPrivateDnsNameOptions_Call) Return(_a0 *ec2.ModifyPrivateDnsNameOptionsOutput, _a1 error) *EC2_ModifyPrivateDnsNameOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyPrivateDnsNameOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyPrivateDnsNameOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyPrivateDnsNameOptionsOutput, error)) *EC2_ModifyPrivateDnsNameOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyPublicIpDnsNameOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyPublicIpDnsNameOptions(ctx context.Context, params *ec2.ModifyPublicIpDnsNameOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyPublicIpDnsNameOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyPublicIpDnsNameOptions")
	}

	var r0 *ec2.ModifyPublicIpDnsNameOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyPublicIpDnsNameOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyPublicIpDnsNameOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyPublicIpDnsNameOptionsInput, ...func(*ec2.Options)) *ec2.ModifyPublicIpDnsNameOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyPublicIpDnsNameOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyPublicIpDnsNameOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyPublicIpDnsNameOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyPublicIpDnsNameOptions'
type EC2_ModifyPublicIpDnsNameOptions_Call struct {
	*mock.Call
}

// ModifyPublicIpDnsNameOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyPublicIpDnsNameOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyPublicIpDnsNameOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyPublicIpDnsNameOptions_Call {
	return &EC2_ModifyPublicIpDnsNameOptions_Call{Call: _e.mock.On("ModifyPublicIpDnsNameOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyPublicIpDnsNameOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyPublicIpDnsNameOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyPublicIpDnsNameOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyPublicIpDnsNameOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyPublicIpDnsNameOptions_Call) Return(_a0 *ec2.ModifyPublicIpDnsNameOptionsOutput, _a1 error) *EC2_ModifyPublicIpDnsNameOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyPublicIpDnsNameOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyPublicIpDnsNameOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyPublicIpDnsNameOptionsOutput, error)) *EC2_ModifyPublicIpDnsNameOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyReservedInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyReservedInstances(ctx context.Context, params *ec2.ModifyReservedInstancesInput, optFns ...func(*ec2.Options)) (*ec2.ModifyReservedInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyReservedInstances")
	}

	var r0 *ec2.ModifyReservedInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyReservedInstancesInput, ...func(*ec2.Options)) (*ec2.ModifyReservedInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyReservedInstancesInput, ...func(*ec2.Options)) *ec2.ModifyReservedInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyReservedInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyReservedInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyReservedInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyReservedInstances'
type EC2_ModifyReservedInstances_Call struct {
	*mock.Call
}

// ModifyReservedInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyReservedInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyReservedInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyReservedInstances_Call {
	return &EC2_ModifyReservedInstances_Call{Call: _e.mock.On("ModifyReservedInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyReservedInstances_Call) Run(run func(ctx context.Context, params *ec2.ModifyReservedInstancesInput, optFns ...func(*ec2.Options))) *EC2_ModifyReservedInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyReservedInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyReservedInstances_Call) Return(_a0 *ec2.ModifyReservedInstancesOutput, _a1 error) *EC2_ModifyReservedInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyReservedInstances_Call) RunAndReturn(run func(context.Context, *ec2.ModifyReservedInstancesInput, ...func(*ec2.Options)) (*ec2.ModifyReservedInstancesOutput, error)) *EC2_ModifyReservedInstances_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyRouteServer provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyRouteServer(ctx context.Context, params *ec2.ModifyRouteServerInput, optFns ...func(*ec2.Options)) (*ec2.ModifyRouteServerOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyRouteServer")
	}

	var r0 *ec2.ModifyRouteServerOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyRouteServerInput, ...func(*ec2.Options)) (*ec2.ModifyRouteServerOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyRouteServerInput, ...func(*ec2.Options)) *ec2.ModifyRouteServerOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyRouteServerOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyRouteServerInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyRouteServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyRouteServer'
type EC2_ModifyRouteServer_Call struct {
	*mock.Call
}

// ModifyRouteServer is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyRouteServerInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyRouteServer(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyRouteServer_Call {
	return &EC2_ModifyRouteServer_Call{Call: _e.mock.On("ModifyRouteServer",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyRouteServer_Call) Run(run func(ctx context.Context, params *ec2.ModifyRouteServerInput, optFns ...func(*ec2.Options))) *EC2_ModifyRouteServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyRouteServerInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyRouteServer_Call) Return(_a0 *ec2.ModifyRouteServerOutput, _a1 error) *EC2_ModifyRouteServer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyRouteServer_Call) RunAndReturn(run func(context.Context, *ec2.ModifyRouteServerInput, ...func(*ec2.Options)) (*ec2.ModifyRouteServerOutput, error)) *EC2_ModifyRouteServer_Call {
	_c.Call.Return(run)
	return _c
}

// ModifySecurityGroupRules provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifySecurityGroupRules(ctx context.Context, params *ec2.ModifySecurityGroupRulesInput, optFns ...func(*ec2.Options)) (*ec2.ModifySecurityGroupRulesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifySecurityGroupRules")
	}

	var r0 *ec2.ModifySecurityGroupRulesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySecurityGroupRulesInput, ...func(*ec2.Options)) (*ec2.ModifySecurityGroupRulesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySecurityGroupRulesInput, ...func(*ec2.Options)) *ec2.ModifySecurityGroupRulesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySecurityGroupRulesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifySecurityGroupRulesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifySecurityGroupRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifySecurityGroupRules'
type EC2_ModifySecurityGroupRules_Call struct {
	*mock.Call
}

// ModifySecurityGroupRules is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifySecurityGroupRulesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifySecurityGroupRules(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifySecurityGroupRules_Call {
	return &EC2_ModifySecurityGroupRules_Call{Call: _e.mock.On("ModifySecurityGroupRules",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifySecurityGroupRules_Call) Run(run func(ctx context.Context, params *ec2.ModifySecurityGroupRulesInput, optFns ...func(*ec2.Options))) *EC2_ModifySecurityGroupRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifySecurityGroupRulesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifySecurityGroupRules_Call) Return(_a0 *ec2.ModifySecurityGroupRulesOutput, _a1 error) *EC2_ModifySecurityGroupRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifySecurityGroupRules_Call) RunAndReturn(run func(context.Context, *ec2.ModifySecurityGroupRulesInput, ...func(*ec2.Options)) (*ec2.ModifySecurityGroupRulesOutput, error)) *EC2_ModifySecurityGroupRules_Call {
	_c.Call.Return(run)
	return _c
}

// ModifySnapshotAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifySnapshotAttribute(ctx context.Context, params *ec2.ModifySnapshotAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifySnapshotAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifySnapshotAttribute")
	}

	var r0 *ec2.ModifySnapshotAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySnapshotAttributeInput, ...func(*ec2.Options)) (*ec2.ModifySnapshotAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySnapshotAttributeInput, ...func(*ec2.Options)) *ec2.ModifySnapshotAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySnapshotAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifySnapshotAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifySnapshotAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifySnapshotAttribute'
type EC2_ModifySnapshotAttribute_Call struct {
	*mock.Call
}

// ModifySnapshotAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifySnapshotAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifySnapshotAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifySnapshotAttribute_Call {
	return &EC2_ModifySnapshotAttribute_Call{Call: _e.mock.On("ModifySnapshotAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifySnapshotAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifySnapshotAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifySnapshotAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifySnapshotAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifySnapshotAttribute_Call) Return(_a0 *ec2.ModifySnapshotAttributeOutput, _a1 error) *EC2_ModifySnapshotAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifySnapshotAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifySnapshotAttributeInput, ...func(*ec2.Options)) (*ec2.ModifySnapshotAttributeOutput, error)) *EC2_ModifySnapshotAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifySnapshotTier provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifySnapshotTier(ctx context.Context, params *ec2.ModifySnapshotTierInput, optFns ...func(*ec2.Options)) (*ec2.ModifySnapshotTierOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifySnapshotTier")
	}

	var r0 *ec2.ModifySnapshotTierOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySnapshotTierInput, ...func(*ec2.Options)) (*ec2.ModifySnapshotTierOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySnapshotTierInput, ...func(*ec2.Options)) *ec2.ModifySnapshotTierOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySnapshotTierOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifySnapshotTierInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifySnapshotTier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifySnapshotTier'
type EC2_ModifySnapshotTier_Call struct {
	*mock.Call
}

// ModifySnapshotTier is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifySnapshotTierInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifySnapshotTier(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifySnapshotTier_Call {
	return &EC2_ModifySnapshotTier_Call{Call: _e.mock.On("ModifySnapshotTier",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifySnapshotTier_Call) Run(run func(ctx context.Context, params *ec2.ModifySnapshotTierInput, optFns ...func(*ec2.Options))) *EC2_ModifySnapshotTier_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifySnapshotTierInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifySnapshotTier_Call) Return(_a0 *ec2.ModifySnapshotTierOutput, _a1 error) *EC2_ModifySnapshotTier_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifySnapshotTier_Call) RunAndReturn(run func(context.Context, *ec2.ModifySnapshotTierInput, ...func(*ec2.Options)) (*ec2.ModifySnapshotTierOutput, error)) *EC2_ModifySnapshotTier_Call {
	_c.Call.Return(run)
	return _c
}

// ModifySpotFleetRequest provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifySpotFleetRequest(ctx context.Context, params *ec2.ModifySpotFleetRequestInput, optFns ...func(*ec2.Options)) (*ec2.ModifySpotFleetRequestOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifySpotFleetRequest")
	}

	var r0 *ec2.ModifySpotFleetRequestOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySpotFleetRequestInput, ...func(*ec2.Options)) (*ec2.ModifySpotFleetRequestOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySpotFleetRequestInput, ...func(*ec2.Options)) *ec2.ModifySpotFleetRequestOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySpotFleetRequestOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifySpotFleetRequestInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifySpotFleetRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifySpotFleetRequest'
type EC2_ModifySpotFleetRequest_Call struct {
	*mock.Call
}

// ModifySpotFleetRequest is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifySpotFleetRequestInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifySpotFleetRequest(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifySpotFleetRequest_Call {
	return &EC2_ModifySpotFleetRequest_Call{Call: _e.mock.On("ModifySpotFleetRequest",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifySpotFleetRequest_Call) Run(run func(ctx context.Context, params *ec2.ModifySpotFleetRequestInput, optFns ...func(*ec2.Options))) *EC2_ModifySpotFleetRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifySpotFleetRequestInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifySpotFleetRequest_Call) Return(_a0 *ec2.ModifySpotFleetRequestOutput, _a1 error) *EC2_ModifySpotFleetRequest_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifySpotFleetRequest_Call) RunAndReturn(run func(context.Context, *ec2.ModifySpotFleetRequestInput, ...func(*ec2.Options)) (*ec2.ModifySpotFleetRequestOutput, error)) *EC2_ModifySpotFleetRequest_Call {
	_c.Call.Return(run)
	return _c
}

// ModifySubnetAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifySubnetAttribute(ctx context.Context, params *ec2.ModifySubnetAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifySubnetAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifySubnetAttribute")
	}

	var r0 *ec2.ModifySubnetAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySubnetAttributeInput, ...func(*ec2.Options)) (*ec2.ModifySubnetAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifySubnetAttributeInput, ...func(*ec2.Options)) *ec2.ModifySubnetAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifySubnetAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifySubnetAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifySubnetAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifySubnetAttribute'
type EC2_ModifySubnetAttribute_Call struct {
	*mock.Call
}

// ModifySubnetAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifySubnetAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifySubnetAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifySubnetAttribute_Call {
	return &EC2_ModifySubnetAttribute_Call{Call: _e.mock.On("ModifySubnetAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifySubnetAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifySubnetAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifySubnetAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifySubnetAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifySubnetAttribute_Call) Return(_a0 *ec2.ModifySubnetAttributeOutput, _a1 error) *EC2_ModifySubnetAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifySubnetAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifySubnetAttributeInput, ...func(*ec2.Options)) (*ec2.ModifySubnetAttributeOutput, error)) *EC2_ModifySubnetAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyTrafficMirrorFilterNetworkServices provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyTrafficMirrorFilterNetworkServices(ctx context.Context, params *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyTrafficMirrorFilterNetworkServices")
	}

	var r0 *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, ...func(*ec2.Options)) *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyTrafficMirrorFilterNetworkServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyTrafficMirrorFilterNetworkServices'
type EC2_ModifyTrafficMirrorFilterNetworkServices_Call struct {
	*mock.Call
}

// ModifyTrafficMirrorFilterNetworkServices is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyTrafficMirrorFilterNetworkServicesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyTrafficMirrorFilterNetworkServices(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyTrafficMirrorFilterNetworkServices_Call {
	return &EC2_ModifyTrafficMirrorFilterNetworkServices_Call{Call: _e.mock.On("ModifyTrafficMirrorFilterNetworkServices",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyTrafficMirrorFilterNetworkServices_Call) Run(run func(ctx context.Context, params *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, optFns ...func(*ec2.Options))) *EC2_ModifyTrafficMirrorFilterNetworkServices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyTrafficMirrorFilterNetworkServicesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyTrafficMirrorFilterNetworkServices_Call) Return(_a0 *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, _a1 error) *EC2_ModifyTrafficMirrorFilterNetworkServices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyTrafficMirrorFilterNetworkServices_Call) RunAndReturn(run func(context.Context, *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error)) *EC2_ModifyTrafficMirrorFilterNetworkServices_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyTrafficMirrorFilterRule provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyTrafficMirrorFilterRule(ctx context.Context, params *ec2.ModifyTrafficMirrorFilterRuleInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyTrafficMirrorFilterRule")
	}

	var r0 *ec2.ModifyTrafficMirrorFilterRuleOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) *ec2.ModifyTrafficMirrorFilterRuleOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorFilterRuleOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyTrafficMirrorFilterRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyTrafficMirrorFilterRule'
type EC2_ModifyTrafficMirrorFilterRule_Call struct {
	*mock.Call
}

// ModifyTrafficMirrorFilterRule is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyTrafficMirrorFilterRuleInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyTrafficMirrorFilterRule(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyTrafficMirrorFilterRule_Call {
	return &EC2_ModifyTrafficMirrorFilterRule_Call{Call: _e.mock.On("ModifyTrafficMirrorFilterRule",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyTrafficMirrorFilterRule_Call) Run(run func(ctx context.Context, params *ec2.ModifyTrafficMirrorFilterRuleInput, optFns ...func(*ec2.Options))) *EC2_ModifyTrafficMirrorFilterRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyTrafficMirrorFilterRuleInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyTrafficMirrorFilterRule_Call) Return(_a0 *ec2.ModifyTrafficMirrorFilterRuleOutput, _a1 error) *EC2_ModifyTrafficMirrorFilterRule_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyTrafficMirrorFilterRule_Call) RunAndReturn(run func(context.Context, *ec2.ModifyTrafficMirrorFilterRuleInput, ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error)) *EC2_ModifyTrafficMirrorFilterRule_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyTrafficMirrorSession provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyTrafficMirrorSession(ctx context.Context, params *ec2.ModifyTrafficMirrorSessionInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorSessionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyTrafficMirrorSession")
	}

	var r0 *ec2.ModifyTrafficMirrorSessionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorSessionInput, ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorSessionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTrafficMirrorSessionInput, ...func(*ec2.Options)) *ec2.ModifyTrafficMirrorSessionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTrafficMirrorSessionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTrafficMirrorSessionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyTrafficMirrorSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyTrafficMirrorSession'
type EC2_ModifyTrafficMirrorSession_Call struct {
	*mock.Call
}

// ModifyTrafficMirrorSession is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyTrafficMirrorSessionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyTrafficMirrorSession(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyTrafficMirrorSession_Call {
	return &EC2_ModifyTrafficMirrorSession_Call{Call: _e.mock.On("ModifyTrafficMirrorSession",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyTrafficMirrorSession_Call) Run(run func(ctx context.Context, params *ec2.ModifyTrafficMirrorSessionInput, optFns ...func(*ec2.Options))) *EC2_ModifyTrafficMirrorSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyTrafficMirrorSessionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyTrafficMirrorSession_Call) Return(_a0 *ec2.ModifyTrafficMirrorSessionOutput, _a1 error) *EC2_ModifyTrafficMirrorSession_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyTrafficMirrorSession_Call) RunAndReturn(run func(context.Context, *ec2.ModifyTrafficMirrorSessionInput, ...func(*ec2.Options)) (*ec2.ModifyTrafficMirrorSessionOutput, error)) *EC2_ModifyTrafficMirrorSession_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyTransitGateway provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyTransitGateway(ctx context.Context, params *ec2.ModifyTransitGatewayInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyTransitGateway")
	}

	var r0 *ec2.ModifyTransitGatewayOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayInput, ...func(*ec2.Options)) *ec2.ModifyTransitGatewayOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTransitGatewayInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyTransitGateway_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyTransitGateway'
type EC2_ModifyTransitGateway_Call struct {
	*mock.Call
}

// ModifyTransitGateway is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyTransitGatewayInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyTransitGateway(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyTransitGateway_Call {
	return &EC2_ModifyTransitGateway_Call{Call: _e.mock.On("ModifyTransitGateway",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyTransitGateway_Call) Run(run func(ctx context.Context, params *ec2.ModifyTransitGatewayInput, optFns ...func(*ec2.Options))) *EC2_ModifyTransitGateway_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyTransitGatewayInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyTransitGateway_Call) Return(_a0 *ec2.ModifyTransitGatewayOutput, _a1 error) *EC2_ModifyTransitGateway_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyTransitGateway_Call) RunAndReturn(run func(context.Context, *ec2.ModifyTransitGatewayInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayOutput, error)) *EC2_ModifyTransitGateway_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyTransitGatewayMeteringPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyTransitGatewayMeteringPolicy(ctx context.Context, params *ec2.ModifyTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayMeteringPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyTransitGatewayMeteringPolicy")
	}

	var r0 *ec2.ModifyTransitGatewayMeteringPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayMeteringPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) *ec2.ModifyTransitGatewayMeteringPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayMeteringPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyTransitGatewayMeteringPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyTransitGatewayMeteringPolicy'
type EC2_ModifyTransitGatewayMeteringPolicy_Call struct {
	*mock.Call
}

// ModifyTransitGatewayMeteringPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyTransitGatewayMeteringPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyTransitGatewayMeteringPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyTransitGatewayMeteringPolicy_Call {
	return &EC2_ModifyTransitGatewayMeteringPolicy_Call{Call: _e.mock.On("ModifyTransitGatewayMeteringPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyTransitGatewayMeteringPolicy_Call) Run(run func(ctx context.Context, params *ec2.ModifyTransitGatewayMeteringPolicyInput, optFns ...func(*ec2.Options))) *EC2_ModifyTransitGatewayMeteringPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyTransitGatewayMeteringPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyTransitGatewayMeteringPolicy_Call) Return(_a0 *ec2.ModifyTransitGatewayMeteringPolicyOutput, _a1 error) *EC2_ModifyTransitGatewayMeteringPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyTransitGatewayMeteringPolicy_Call) RunAndReturn(run func(context.Context, *ec2.ModifyTransitGatewayMeteringPolicyInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayMeteringPolicyOutput, error)) *EC2_ModifyTransitGatewayMeteringPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyTransitGatewayPrefixListReference provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyTransitGatewayPrefixListReference(ctx context.Context, params *ec2.ModifyTransitGatewayPrefixListReferenceInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyTransitGatewayPrefixListReference")
	}

	var r0 *ec2.ModifyTransitGatewayPrefixListReferenceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) *ec2.ModifyTransitGatewayPrefixListReferenceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyTransitGatewayPrefixListReference_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyTransitGatewayPrefixListReference'
type EC2_ModifyTransitGatewayPrefixListReference_Call struct {
	*mock.Call
}

// ModifyTransitGatewayPrefixListReference is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyTransitGatewayPrefixListReferenceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyTransitGatewayPrefixListReference(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyTransitGatewayPrefixListReference_Call {
	return &EC2_ModifyTransitGatewayPrefixListReference_Call{Call: _e.mock.On("ModifyTransitGatewayPrefixListReference",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyTransitGatewayPrefixListReference_Call) Run(run func(ctx context.Context, params *ec2.ModifyTransitGatewayPrefixListReferenceInput, optFns ...func(*ec2.Options))) *EC2_ModifyTransitGatewayPrefixListReference_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyTransitGatewayPrefixListReferenceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyTransitGatewayPrefixListReference_Call) Return(_a0 *ec2.ModifyTransitGatewayPrefixListReferenceOutput, _a1 error) *EC2_ModifyTransitGatewayPrefixListReference_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyTransitGatewayPrefixListReference_Call) RunAndReturn(run func(context.Context, *ec2.ModifyTransitGatewayPrefixListReferenceInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error)) *EC2_ModifyTransitGatewayPrefixListReference_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyTransitGatewayVpcAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyTransitGatewayVpcAttachment(ctx context.Context, params *ec2.ModifyTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyTransitGatewayVpcAttachment")
	}

	var r0 *ec2.ModifyTransitGatewayVpcAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) *ec2.ModifyTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyTransitGatewayVpcAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyTransitGatewayVpcAttachment'
type EC2_ModifyTransitGatewayVpcAttachment_Call struct {
	*mock.Call
}

// ModifyTransitGatewayVpcAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyTransitGatewayVpcAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyTransitGatewayVpcAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyTransitGatewayVpcAttachment_Call {
	return &EC2_ModifyTransitGatewayVpcAttachment_Call{Call: _e.mock.On("ModifyTransitGatewayVpcAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyTransitGatewayVpcAttachment_Call) Run(run func(ctx context.Context, params *ec2.ModifyTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options))) *EC2_ModifyTransitGatewayVpcAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyTransitGatewayVpcAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyTransitGatewayVpcAttachment_Call) Return(_a0 *ec2.ModifyTransitGatewayVpcAttachmentOutput, _a1 error) *EC2_ModifyTransitGatewayVpcAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyTransitGatewayVpcAttachment_Call) RunAndReturn(run func(context.Context, *ec2.ModifyTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error)) *EC2_ModifyTransitGatewayVpcAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVerifiedAccessEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVerifiedAccessEndpoint(ctx context.Context, params *ec2.ModifyVerifiedAccessEndpointInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVerifiedAccessEndpoint")
	}

	var r0 *ec2.ModifyVerifiedAccessEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessEndpointInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessEndpointInput, ...func(*ec2.Options)) *ec2.ModifyVerifiedAccessEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVerifiedAccessEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVerifiedAccessEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVerifiedAccessEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVerifiedAccessEndpoint'
type EC2_ModifyVerifiedAccessEndpoint_Call struct {
	*mock.Call
}

// ModifyVerifiedAccessEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVerifiedAccessEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVerifiedAccessEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVerifiedAccessEndpoint_Call {
	return &EC2_ModifyVerifiedAccessEndpoint_Call{Call: _e.mock.On("ModifyVerifiedAccessEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVerifiedAccessEndpoint_Call) Run(run func(ctx context.Context, params *ec2.ModifyVerifiedAccessEndpointInput, optFns ...func(*ec2.Options))) *EC2_ModifyVerifiedAccessEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVerifiedAccessEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVerifiedAccessEndpoint_Call) Return(_a0 *ec2.ModifyVerifiedAccessEndpointOutput, _a1 error) *EC2_ModifyVerifiedAccessEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVerifiedAccessEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVerifiedAccessEndpointInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessEndpointOutput, error)) *EC2_ModifyVerifiedAccessEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVerifiedAccessEndpointPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVerifiedAccessEndpointPolicy(ctx context.Context, params *ec2.ModifyVerifiedAccessEndpointPolicyInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVerifiedAccessEndpointPolicy")
	}

	var r0 *ec2.ModifyVerifiedAccessEndpointPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessEndpointPolicyInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessEndpointPolicyInput, ...func(*ec2.Options)) *ec2.ModifyVerifiedAccessEndpointPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVerifiedAccessEndpointPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVerifiedAccessEndpointPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVerifiedAccessEndpointPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVerifiedAccessEndpointPolicy'
type EC2_ModifyVerifiedAccessEndpointPolicy_Call struct {
	*mock.Call
}

// ModifyVerifiedAccessEndpointPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVerifiedAccessEndpointPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVerifiedAccessEndpointPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVerifiedAccessEndpointPolicy_Call {
	return &EC2_ModifyVerifiedAccessEndpointPolicy_Call{Call: _e.mock.On("ModifyVerifiedAccessEndpointPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVerifiedAccessEndpointPolicy_Call) Run(run func(ctx context.Context, params *ec2.ModifyVerifiedAccessEndpointPolicyInput, optFns ...func(*ec2.Options))) *EC2_ModifyVerifiedAccessEndpointPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVerifiedAccessEndpointPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVerifiedAccessEndpointPolicy_Call) Return(_a0 *ec2.ModifyVerifiedAccessEndpointPolicyOutput, _a1 error) *EC2_ModifyVerifiedAccessEndpointPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVerifiedAccessEndpointPolicy_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVerifiedAccessEndpointPolicyInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error)) *EC2_ModifyVerifiedAccessEndpointPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVerifiedAccessGroup provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVerifiedAccessGroup(ctx context.Context, params *ec2.ModifyVerifiedAccessGroupInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessGroupOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVerifiedAccessGroup")
	}

	var r0 *ec2.ModifyVerifiedAccessGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessGroupInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessGroupOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessGroupInput, ...func(*ec2.Options)) *ec2.ModifyVerifiedAccessGroupOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVerifiedAccessGroupOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVerifiedAccessGroupInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVerifiedAccessGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVerifiedAccessGroup'
type EC2_ModifyVerifiedAccessGroup_Call struct {
	*mock.Call
}

// ModifyVerifiedAccessGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVerifiedAccessGroupInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVerifiedAccessGroup(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVerifiedAccessGroup_Call {
	return &EC2_ModifyVerifiedAccessGroup_Call{Call: _e.mock.On("ModifyVerifiedAccessGroup",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVerifiedAccessGroup_Call) Run(run func(ctx context.Context, params *ec2.ModifyVerifiedAccessGroupInput, optFns ...func(*ec2.Options))) *EC2_ModifyVerifiedAccessGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVerifiedAccessGroupInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVerifiedAccessGroup_Call) Return(_a0 *ec2.ModifyVerifiedAccessGroupOutput, _a1 error) *EC2_ModifyVerifiedAccessGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVerifiedAccessGroup_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVerifiedAccessGroupInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessGroupOutput, error)) *EC2_ModifyVerifiedAccessGroup_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVerifiedAccessGroupPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVerifiedAccessGroupPolicy(ctx context.Context, params *ec2.ModifyVerifiedAccessGroupPolicyInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVerifiedAccessGroupPolicy")
	}

	var r0 *ec2.ModifyVerifiedAccessGroupPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessGroupPolicyInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessGroupPolicyInput, ...func(*ec2.Options)) *ec2.ModifyVerifiedAccessGroupPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVerifiedAccessGroupPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVerifiedAccessGroupPolicyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVerifiedAccessGroupPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVerifiedAccessGroupPolicy'
type EC2_ModifyVerifiedAccessGroupPolicy_Call struct {
	*mock.Call
}

// ModifyVerifiedAccessGroupPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVerifiedAccessGroupPolicyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVerifiedAccessGroupPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVerifiedAccessGroupPolicy_Call {
	return &EC2_ModifyVerifiedAccessGroupPolicy_Call{Call: _e.mock.On("ModifyVerifiedAccessGroupPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVerifiedAccessGroupPolicy_Call) Run(run func(ctx context.Context, params *ec2.ModifyVerifiedAccessGroupPolicyInput, optFns ...func(*ec2.Options))) *EC2_ModifyVerifiedAccessGroupPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVerifiedAccessGroupPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVerifiedAccessGroupPolicy_Call) Return(_a0 *ec2.ModifyVerifiedAccessGroupPolicyOutput, _a1 error) *EC2_ModifyVerifiedAccessGroupPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVerifiedAccessGroupPolicy_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVerifiedAccessGroupPolicyInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error)) *EC2_ModifyVerifiedAccessGroupPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVerifiedAccessInstance provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVerifiedAccessInstance(ctx context.Context, params *ec2.ModifyVerifiedAccessInstanceInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessInstanceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVerifiedAccessInstance")
	}

	var r0 *ec2.ModifyVerifiedAccessInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessInstanceInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessInstanceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessInstanceInput, ...func(*ec2.Options)) *ec2.ModifyVerifiedAccessInstanceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVerifiedAccessInstanceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVerifiedAccessInstanceInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVerifiedAccessInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVerifiedAccessInstance'
type EC2_ModifyVerifiedAccessInstance_Call struct {
	*mock.Call
}

// ModifyVerifiedAccessInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVerifiedAccessInstanceInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVerifiedAccessInstance(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVerifiedAccessInstance_Call {
	return &EC2_ModifyVerifiedAccessInstance_Call{Call: _e.mock.On("ModifyVerifiedAccessInstance",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVerifiedAccessInstance_Call) Run(run func(ctx context.Context, params *ec2.ModifyVerifiedAccessInstanceInput, optFns ...func(*ec2.Options))) *EC2_ModifyVerifiedAccessInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVerifiedAccessInstanceInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVerifiedAccessInstance_Call) Return(_a0 *ec2.ModifyVerifiedAccessInstanceOutput, _a1 error) *EC2_ModifyVerifiedAccessInstance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVerifiedAccessInstance_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVerifiedAccessInstanceInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessInstanceOutput, error)) *EC2_ModifyVerifiedAccessInstance_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVerifiedAccessInstanceLoggingConfiguration provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVerifiedAccessInstanceLoggingConfiguration(ctx context.Context, params *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVerifiedAccessInstanceLoggingConfiguration")
	}

	var r0 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, ...func(*ec2.Options)) *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVerifiedAccessInstanceLoggingConfiguration'
type EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call struct {
	*mock.Call
}

// ModifyVerifiedAccessInstanceLoggingConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVerifiedAccessInstanceLoggingConfiguration(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call {
	return &EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call{Call: _e.mock.On("ModifyVerifiedAccessInstanceLoggingConfiguration",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call) Run(run func(ctx context.Context, params *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, optFns ...func(*ec2.Options))) *EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call) Return(_a0 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, _a1 error) *EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error)) *EC2_ModifyVerifiedAccessInstanceLoggingConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVerifiedAccessTrustProvider provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVerifiedAccessTrustProvider(ctx context.Context, params *ec2.ModifyVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVerifiedAccessTrustProvider")
	}

	var r0 *ec2.ModifyVerifiedAccessTrustProviderOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) *ec2.ModifyVerifiedAccessTrustProviderOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVerifiedAccessTrustProviderOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVerifiedAccessTrustProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVerifiedAccessTrustProvider'
type EC2_ModifyVerifiedAccessTrustProvider_Call struct {
	*mock.Call
}

// ModifyVerifiedAccessTrustProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVerifiedAccessTrustProviderInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVerifiedAccessTrustProvider(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVerifiedAccessTrustProvider_Call {
	return &EC2_ModifyVerifiedAccessTrustProvider_Call{Call: _e.mock.On("ModifyVerifiedAccessTrustProvider",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVerifiedAccessTrustProvider_Call) Run(run func(ctx context.Context, params *ec2.ModifyVerifiedAccessTrustProviderInput, optFns ...func(*ec2.Options))) *EC2_ModifyVerifiedAccessTrustProvider_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVerifiedAccessTrustProviderInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVerifiedAccessTrustProvider_Call) Return(_a0 *ec2.ModifyVerifiedAccessTrustProviderOutput, _a1 error) *EC2_ModifyVerifiedAccessTrustProvider_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVerifiedAccessTrustProvider_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVerifiedAccessTrustProviderInput, ...func(*ec2.Options)) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error)) *EC2_ModifyVerifiedAccessTrustProvider_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVolume provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVolume(ctx context.Context, params *ec2.ModifyVolumeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVolumeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVolume")
	}

	var r0 *ec2.ModifyVolumeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVolumeInput, ...func(*ec2.Options)) (*ec2.ModifyVolumeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVolumeInput, ...func(*ec2.Options)) *ec2.ModifyVolumeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVolumeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVolumeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVolume'
type EC2_ModifyVolume_Call struct {
	*mock.Call
}

// ModifyVolume is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVolumeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVolume(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVolume_Call {
	return &EC2_ModifyVolume_Call{Call: _e.mock.On("ModifyVolume",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVolume_Call) Run(run func(ctx context.Context, params *ec2.ModifyVolumeInput, optFns ...func(*ec2.Options))) *EC2_ModifyVolume_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVolumeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVolume_Call) Return(_a0 *ec2.ModifyVolumeOutput, _a1 error) *EC2_ModifyVolume_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVolume_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVolumeInput, ...func(*ec2.Options)) (*ec2.ModifyVolumeOutput, error)) *EC2_ModifyVolume_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVolumeAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVolumeAttribute(ctx context.Context, params *ec2.ModifyVolumeAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVolumeAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVolumeAttribute")
	}

	var r0 *ec2.ModifyVolumeAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVolumeAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyVolumeAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVolumeAttributeInput, ...func(*ec2.Options)) *ec2.ModifyVolumeAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVolumeAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVolumeAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVolumeAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVolumeAttribute'
type EC2_ModifyVolumeAttribute_Call struct {
	*mock.Call
}

// ModifyVolumeAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVolumeAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVolumeAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVolumeAttribute_Call {
	return &EC2_ModifyVolumeAttribute_Call{Call: _e.mock.On("ModifyVolumeAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVolumeAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifyVolumeAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifyVolumeAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVolumeAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVolumeAttribute_Call) Return(_a0 *ec2.ModifyVolumeAttributeOutput, _a1 error) *EC2_ModifyVolumeAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVolumeAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVolumeAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyVolumeAttributeOutput, error)) *EC2_ModifyVolumeAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcAttribute(ctx context.Context, params *ec2.ModifyVpcAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcAttribute")
	}

	var r0 *ec2.ModifyVpcAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyVpcAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcAttributeInput, ...func(*ec2.Options)) *ec2.ModifyVpcAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcAttribute'
type EC2_ModifyVpcAttribute_Call struct {
	*mock.Call
}

// ModifyVpcAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcAttribute_Call {
	return &EC2_ModifyVpcAttribute_Call{Call: _e.mock.On("ModifyVpcAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcAttribute_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcAttributeInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcAttribute_Call) Return(_a0 *ec2.ModifyVpcAttributeOutput, _a1 error) *EC2_ModifyVpcAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcAttributeInput, ...func(*ec2.Options)) (*ec2.ModifyVpcAttributeOutput, error)) *EC2_ModifyVpcAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcBlockPublicAccessExclusion provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcBlockPublicAccessExclusion(ctx context.Context, params *ec2.ModifyVpcBlockPublicAccessExclusionInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcBlockPublicAccessExclusionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcBlockPublicAccessExclusion")
	}

	var r0 *ec2.ModifyVpcBlockPublicAccessExclusionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) (*ec2.ModifyVpcBlockPublicAccessExclusionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) *ec2.ModifyVpcBlockPublicAccessExclusionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcBlockPublicAccessExclusionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcBlockPublicAccessExclusion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcBlockPublicAccessExclusion'
type EC2_ModifyVpcBlockPublicAccessExclusion_Call struct {
	*mock.Call
}

// ModifyVpcBlockPublicAccessExclusion is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcBlockPublicAccessExclusionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcBlockPublicAccessExclusion(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcBlockPublicAccessExclusion_Call {
	return &EC2_ModifyVpcBlockPublicAccessExclusion_Call{Call: _e.mock.On("ModifyVpcBlockPublicAccessExclusion",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcBlockPublicAccessExclusion_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcBlockPublicAccessExclusionInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcBlockPublicAccessExclusion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcBlockPublicAccessExclusionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcBlockPublicAccessExclusion_Call) Return(_a0 *ec2.ModifyVpcBlockPublicAccessExclusionOutput, _a1 error) *EC2_ModifyVpcBlockPublicAccessExclusion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcBlockPublicAccessExclusion_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcBlockPublicAccessExclusionInput, ...func(*ec2.Options)) (*ec2.ModifyVpcBlockPublicAccessExclusionOutput, error)) *EC2_ModifyVpcBlockPublicAccessExclusion_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcBlockPublicAccessOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcBlockPublicAccessOptions(ctx context.Context, params *ec2.ModifyVpcBlockPublicAccessOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcBlockPublicAccessOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcBlockPublicAccessOptions")
	}

	var r0 *ec2.ModifyVpcBlockPublicAccessOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcBlockPublicAccessOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpcBlockPublicAccessOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcBlockPublicAccessOptionsInput, ...func(*ec2.Options)) *ec2.ModifyVpcBlockPublicAccessOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcBlockPublicAccessOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcBlockPublicAccessOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcBlockPublicAccessOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcBlockPublicAccessOptions'
type EC2_ModifyVpcBlockPublicAccessOptions_Call struct {
	*mock.Call
}

// ModifyVpcBlockPublicAccessOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcBlockPublicAccessOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcBlockPublicAccessOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcBlockPublicAccessOptions_Call {
	return &EC2_ModifyVpcBlockPublicAccessOptions_Call{Call: _e.mock.On("ModifyVpcBlockPublicAccessOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcBlockPublicAccessOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcBlockPublicAccessOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcBlockPublicAccessOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcBlockPublicAccessOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcBlockPublicAccessOptions_Call) Return(_a0 *ec2.ModifyVpcBlockPublicAccessOptionsOutput, _a1 error) *EC2_ModifyVpcBlockPublicAccessOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcBlockPublicAccessOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcBlockPublicAccessOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpcBlockPublicAccessOptionsOutput, error)) *EC2_ModifyVpcBlockPublicAccessOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcEncryptionControl provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcEncryptionControl(ctx context.Context, params *ec2.ModifyVpcEncryptionControlInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEncryptionControlOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcEncryptionControl")
	}

	var r0 *ec2.ModifyVpcEncryptionControlOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEncryptionControlOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEncryptionControlInput, ...func(*ec2.Options)) *ec2.ModifyVpcEncryptionControlOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEncryptionControlOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEncryptionControlInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcEncryptionControl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcEncryptionControl'
type EC2_ModifyVpcEncryptionControl_Call struct {
	*mock.Call
}

// ModifyVpcEncryptionControl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcEncryptionControlInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcEncryptionControl(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcEncryptionControl_Call {
	return &EC2_ModifyVpcEncryptionControl_Call{Call: _e.mock.On("ModifyVpcEncryptionControl",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcEncryptionControl_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcEncryptionControlInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcEncryptionControl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcEncryptionControlInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcEncryptionControl_Call) Return(_a0 *ec2.ModifyVpcEncryptionControlOutput, _a1 error) *EC2_ModifyVpcEncryptionControl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcEncryptionControl_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcEncryptionControlInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEncryptionControlOutput, error)) *EC2_ModifyVpcEncryptionControl_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcEndpoint provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcEndpoint(ctx context.Context, params *ec2.ModifyVpcEndpointInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcEndpoint")
	}

	var r0 *ec2.ModifyVpcEndpointOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointInput, ...func(*ec2.Options)) *ec2.ModifyVpcEndpointOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcEndpoint'
type EC2_ModifyVpcEndpoint_Call struct {
	*mock.Call
}

// ModifyVpcEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcEndpointInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcEndpoint(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcEndpoint_Call {
	return &EC2_ModifyVpcEndpoint_Call{Call: _e.mock.On("ModifyVpcEndpoint",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcEndpoint_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcEndpointInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcEndpointInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcEndpoint_Call) Return(_a0 *ec2.ModifyVpcEndpointOutput, _a1 error) *EC2_ModifyVpcEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcEndpoint_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcEndpointInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointOutput, error)) *EC2_ModifyVpcEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcEndpointConnectionNotification provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcEndpointConnectionNotification(ctx context.Context, params *ec2.ModifyVpcEndpointConnectionNotificationInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcEndpointConnectionNotification")
	}

	var r0 *ec2.ModifyVpcEndpointConnectionNotificationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointConnectionNotificationInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointConnectionNotificationInput, ...func(*ec2.Options)) *ec2.ModifyVpcEndpointConnectionNotificationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointConnectionNotificationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcEndpointConnectionNotification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcEndpointConnectionNotification'
type EC2_ModifyVpcEndpointConnectionNotification_Call struct {
	*mock.Call
}

// ModifyVpcEndpointConnectionNotification is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcEndpointConnectionNotificationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcEndpointConnectionNotification(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcEndpointConnectionNotification_Call {
	return &EC2_ModifyVpcEndpointConnectionNotification_Call{Call: _e.mock.On("ModifyVpcEndpointConnectionNotification",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcEndpointConnectionNotification_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcEndpointConnectionNotificationInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcEndpointConnectionNotification_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcEndpointConnectionNotificationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcEndpointConnectionNotification_Call) Return(_a0 *ec2.ModifyVpcEndpointConnectionNotificationOutput, _a1 error) *EC2_ModifyVpcEndpointConnectionNotification_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcEndpointConnectionNotification_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcEndpointConnectionNotificationInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error)) *EC2_ModifyVpcEndpointConnectionNotification_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcEndpointServiceConfiguration provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcEndpointServiceConfiguration(ctx context.Context, params *ec2.ModifyVpcEndpointServiceConfigurationInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcEndpointServiceConfiguration")
	}

	var r0 *ec2.ModifyVpcEndpointServiceConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointServiceConfigurationInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointServiceConfigurationInput, ...func(*ec2.Options)) *ec2.ModifyVpcEndpointServiceConfigurationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointServiceConfigurationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcEndpointServiceConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcEndpointServiceConfiguration'
type EC2_ModifyVpcEndpointServiceConfiguration_Call struct {
	*mock.Call
}

// ModifyVpcEndpointServiceConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcEndpointServiceConfigurationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcEndpointServiceConfiguration(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcEndpointServiceConfiguration_Call {
	return &EC2_ModifyVpcEndpointServiceConfiguration_Call{Call: _e.mock.On("ModifyVpcEndpointServiceConfiguration",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcEndpointServiceConfiguration_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcEndpointServiceConfigurationInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcEndpointServiceConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcEndpointServiceConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcEndpointServiceConfiguration_Call) Return(_a0 *ec2.ModifyVpcEndpointServiceConfigurationOutput, _a1 error) *EC2_ModifyVpcEndpointServiceConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcEndpointServiceConfiguration_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcEndpointServiceConfigurationInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error)) *EC2_ModifyVpcEndpointServiceConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcEndpointServicePayerResponsibility provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcEndpointServicePayerResponsibility(ctx context.Context, params *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcEndpointServicePayerResponsibility")
	}

	var r0 *ec2.ModifyVpcEndpointServicePayerResponsibilityOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, ...func(*ec2.Options)) *ec2.ModifyVpcEndpointServicePayerResponsibilityOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcEndpointServicePayerResponsibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcEndpointServicePayerResponsibility'
type EC2_ModifyVpcEndpointServicePayerResponsibility_Call struct {
	*mock.Call
}

// ModifyVpcEndpointServicePayerResponsibility is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcEndpointServicePayerResponsibilityInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcEndpointServicePayerResponsibility(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcEndpointServicePayerResponsibility_Call {
	return &EC2_ModifyVpcEndpointServicePayerResponsibility_Call{Call: _e.mock.On("ModifyVpcEndpointServicePayerResponsibility",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcEndpointServicePayerResponsibility_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcEndpointServicePayerResponsibility_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcEndpointServicePayerResponsibilityInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcEndpointServicePayerResponsibility_Call) Return(_a0 *ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, _a1 error) *EC2_ModifyVpcEndpointServicePayerResponsibility_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcEndpointServicePayerResponsibility_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error)) *EC2_ModifyVpcEndpointServicePayerResponsibility_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcEndpointServicePermissions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcEndpointServicePermissions(ctx context.Context, params *ec2.ModifyVpcEndpointServicePermissionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcEndpointServicePermissions")
	}

	var r0 *ec2.ModifyVpcEndpointServicePermissionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointServicePermissionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcEndpointServicePermissionsInput, ...func(*ec2.Options)) *ec2.ModifyVpcEndpointServicePermissionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcEndpointServicePermissionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcEndpointServicePermissionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcEndpointServicePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcEndpointServicePermissions'
type EC2_ModifyVpcEndpointServicePermissions_Call struct {
	*mock.Call
}

// ModifyVpcEndpointServicePermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcEndpointServicePermissionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcEndpointServicePermissions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcEndpointServicePermissions_Call {
	return &EC2_ModifyVpcEndpointServicePermissions_Call{Call: _e.mock.On("ModifyVpcEndpointServicePermissions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcEndpointServicePermissions_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcEndpointServicePermissionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcEndpointServicePermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcEndpointServicePermissionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcEndpointServicePermissions_Call) Return(_a0 *ec2.ModifyVpcEndpointServicePermissionsOutput, _a1 error) *EC2_ModifyVpcEndpointServicePermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcEndpointServicePermissions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcEndpointServicePermissionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error)) *EC2_ModifyVpcEndpointServicePermissions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcPeeringConnectionOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcPeeringConnectionOptions(ctx context.Context, params *ec2.ModifyVpcPeeringConnectionOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcPeeringConnectionOptions")
	}

	var r0 *ec2.ModifyVpcPeeringConnectionOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcPeeringConnectionOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcPeeringConnectionOptionsInput, ...func(*ec2.Options)) *ec2.ModifyVpcPeeringConnectionOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcPeeringConnectionOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcPeeringConnectionOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcPeeringConnectionOptions'
type EC2_ModifyVpcPeeringConnectionOptions_Call struct {
	*mock.Call
}

// ModifyVpcPeeringConnectionOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcPeeringConnectionOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcPeeringConnectionOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcPeeringConnectionOptions_Call {
	return &EC2_ModifyVpcPeeringConnectionOptions_Call{Call: _e.mock.On("ModifyVpcPeeringConnectionOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcPeeringConnectionOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcPeeringConnectionOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcPeeringConnectionOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcPeeringConnectionOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcPeeringConnectionOptions_Call) Return(_a0 *ec2.ModifyVpcPeeringConnectionOptionsOutput, _a1 error) *EC2_ModifyVpcPeeringConnectionOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcPeeringConnectionOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcPeeringConnectionOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error)) *EC2_ModifyVpcPeeringConnectionOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpcTenancy provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpcTenancy(ctx context.Context, params *ec2.ModifyVpcTenancyInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpcTenancyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpcTenancy")
	}

	var r0 *ec2.ModifyVpcTenancyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcTenancyInput, ...func(*ec2.Options)) (*ec2.ModifyVpcTenancyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpcTenancyInput, ...func(*ec2.Options)) *ec2.ModifyVpcTenancyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpcTenancyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpcTenancyInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpcTenancy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpcTenancy'
type EC2_ModifyVpcTenancy_Call struct {
	*mock.Call
}

// ModifyVpcTenancy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpcTenancyInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpcTenancy(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpcTenancy_Call {
	return &EC2_ModifyVpcTenancy_Call{Call: _e.mock.On("ModifyVpcTenancy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpcTenancy_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpcTenancyInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpcTenancy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpcTenancyInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpcTenancy_Call) Return(_a0 *ec2.ModifyVpcTenancyOutput, _a1 error) *EC2_ModifyVpcTenancy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpcTenancy_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpcTenancyInput, ...func(*ec2.Options)) (*ec2.ModifyVpcTenancyOutput, error)) *EC2_ModifyVpcTenancy_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpnConnection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpnConnection(ctx context.Context, params *ec2.ModifyVpnConnectionInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpnConnectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpnConnection")
	}

	var r0 *ec2.ModifyVpnConnectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnConnectionInput, ...func(*ec2.Options)) (*ec2.ModifyVpnConnectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnConnectionInput, ...func(*ec2.Options)) *ec2.ModifyVpnConnectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnConnectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpnConnectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpnConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpnConnection'
type EC2_ModifyVpnConnection_Call struct {
	*mock.Call
}

// ModifyVpnConnection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpnConnectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpnConnection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpnConnection_Call {
	return &EC2_ModifyVpnConnection_Call{Call: _e.mock.On("ModifyVpnConnection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpnConnection_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpnConnectionInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpnConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpnConnectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpnConnection_Call) Return(_a0 *ec2.ModifyVpnConnectionOutput, _a1 error) *EC2_ModifyVpnConnection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpnConnection_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpnConnectionInput, ...func(*ec2.Options)) (*ec2.ModifyVpnConnectionOutput, error)) *EC2_ModifyVpnConnection_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpnConnectionOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpnConnectionOptions(ctx context.Context, params *ec2.ModifyVpnConnectionOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpnConnectionOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpnConnectionOptions")
	}

	var r0 *ec2.ModifyVpnConnectionOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnConnectionOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpnConnectionOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnConnectionOptionsInput, ...func(*ec2.Options)) *ec2.ModifyVpnConnectionOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnConnectionOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpnConnectionOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpnConnectionOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpnConnectionOptions'
type EC2_ModifyVpnConnectionOptions_Call struct {
	*mock.Call
}

// ModifyVpnConnectionOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpnConnectionOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpnConnectionOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpnConnectionOptions_Call {
	return &EC2_ModifyVpnConnectionOptions_Call{Call: _e.mock.On("ModifyVpnConnectionOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpnConnectionOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpnConnectionOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpnConnectionOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpnConnectionOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpnConnectionOptions_Call) Return(_a0 *ec2.ModifyVpnConnectionOptionsOutput, _a1 error) *EC2_ModifyVpnConnectionOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpnConnectionOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpnConnectionOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpnConnectionOptionsOutput, error)) *EC2_ModifyVpnConnectionOptions_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpnTunnelCertificate provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpnTunnelCertificate(ctx context.Context, params *ec2.ModifyVpnTunnelCertificateInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpnTunnelCertificateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpnTunnelCertificate")
	}

	var r0 *ec2.ModifyVpnTunnelCertificateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnTunnelCertificateInput, ...func(*ec2.Options)) (*ec2.ModifyVpnTunnelCertificateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnTunnelCertificateInput, ...func(*ec2.Options)) *ec2.ModifyVpnTunnelCertificateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnTunnelCertificateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpnTunnelCertificateInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpnTunnelCertificate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpnTunnelCertificate'
type EC2_ModifyVpnTunnelCertificate_Call struct {
	*mock.Call
}

// ModifyVpnTunnelCertificate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpnTunnelCertificateInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpnTunnelCertificate(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpnTunnelCertificate_Call {
	return &EC2_ModifyVpnTunnelCertificate_Call{Call: _e.mock.On("ModifyVpnTunnelCertificate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpnTunnelCertificate_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpnTunnelCertificateInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpnTunnelCertificate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpnTunnelCertificateInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpnTunnelCertificate_Call) Return(_a0 *ec2.ModifyVpnTunnelCertificateOutput, _a1 error) *EC2_ModifyVpnTunnelCertificate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpnTunnelCertificate_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpnTunnelCertificateInput, ...func(*ec2.Options)) (*ec2.ModifyVpnTunnelCertificateOutput, error)) *EC2_ModifyVpnTunnelCertificate_Call {
	_c.Call.Return(run)
	return _c
}

// ModifyVpnTunnelOptions provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ModifyVpnTunnelOptions(ctx context.Context, params *ec2.ModifyVpnTunnelOptionsInput, optFns ...func(*ec2.Options)) (*ec2.ModifyVpnTunnelOptionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ModifyVpnTunnelOptions")
	}

	var r0 *ec2.ModifyVpnTunnelOptionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnTunnelOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpnTunnelOptionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ModifyVpnTunnelOptionsInput, ...func(*ec2.Options)) *ec2.ModifyVpnTunnelOptionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ModifyVpnTunnelOptionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ModifyVpnTunnelOptionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ModifyVpnTunnelOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyVpnTunnelOptions'
type EC2_ModifyVpnTunnelOptions_Call struct {
	*mock.Call
}

// ModifyVpnTunnelOptions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ModifyVpnTunnelOptionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ModifyVpnTunnelOptions(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ModifyVpnTunnelOptions_Call {
	return &EC2_ModifyVpnTunnelOptions_Call{Call: _e.mock.On("ModifyVpnTunnelOptions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ModifyVpnTunnelOptions_Call) Run(run func(ctx context.Context, params *ec2.ModifyVpnTunnelOptionsInput, optFns ...func(*ec2.Options))) *EC2_ModifyVpnTunnelOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ModifyVpnTunnelOptionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ModifyVpnTunnelOptions_Call) Return(_a0 *ec2.ModifyVpnTunnelOptionsOutput, _a1 error) *EC2_ModifyVpnTunnelOptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ModifyVpnTunnelOptions_Call) RunAndReturn(run func(context.Context, *ec2.ModifyVpnTunnelOptionsInput, ...func(*ec2.Options)) (*ec2.ModifyVpnTunnelOptionsOutput, error)) *EC2_ModifyVpnTunnelOptions_Call {
	_c.Call.Return(run)
	return _c
}

// MonitorInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) MonitorInstances(ctx context.Context, params *ec2.MonitorInstancesInput, optFns ...func(*ec2.Options)) (*ec2.MonitorInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for MonitorInstances")
	}

	var r0 *ec2.MonitorInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MonitorInstancesInput, ...func(*ec2.Options)) (*ec2.MonitorInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MonitorInstancesInput, ...func(*ec2.Options)) *ec2.MonitorInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.MonitorInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.MonitorInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_MonitorInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MonitorInstances'
type EC2_MonitorInstances_Call struct {
	*mock.Call
}

// MonitorInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.MonitorInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) MonitorInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_MonitorInstances_Call {
	return &EC2_MonitorInstances_Call{Call: _e.mock.On("MonitorInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_MonitorInstances_Call) Run(run func(ctx context.Context, params *ec2.MonitorInstancesInput, optFns ...func(*ec2.Options))) *EC2_MonitorInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.MonitorInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_MonitorInstances_Call) Return(_a0 *ec2.MonitorInstancesOutput, _a1 error) *EC2_MonitorInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_MonitorInstances_Call) RunAndReturn(run func(context.Context, *ec2.MonitorInstancesInput, ...func(*ec2.Options)) (*ec2.MonitorInstancesOutput, error)) *EC2_MonitorInstances_Call {
	_c.Call.Return(run)
	return _c
}

// MoveAddressToVpc provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) MoveAddressToVpc(ctx context.Context, params *ec2.MoveAddressToVpcInput, optFns ...func(*ec2.Options)) (*ec2.MoveAddressToVpcOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for MoveAddressToVpc")
	}

	var r0 *ec2.MoveAddressToVpcOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MoveAddressToVpcInput, ...func(*ec2.Options)) (*ec2.MoveAddressToVpcOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MoveAddressToVpcInput, ...func(*ec2.Options)) *ec2.MoveAddressToVpcOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.MoveAddressToVpcOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.MoveAddressToVpcInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_MoveAddressToVpc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MoveAddressToVpc'
type EC2_MoveAddressToVpc_Call struct {
	*mock.Call
}

// MoveAddressToVpc is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.MoveAddressToVpcInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) MoveAddressToVpc(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_MoveAddressToVpc_Call {
	return &EC2_MoveAddressToVpc_Call{Call: _e.mock.On("MoveAddressToVpc",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_MoveAddressToVpc_Call) Run(run func(ctx context.Context, params *ec2.MoveAddressToVpcInput, optFns ...func(*ec2.Options))) *EC2_MoveAddressToVpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.MoveAddressToVpcInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_MoveAddressToVpc_Call) Return(_a0 *ec2.MoveAddressToVpcOutput, _a1 error) *EC2_MoveAddressToVpc_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_MoveAddressToVpc_Call) RunAndReturn(run func(context.Context, *ec2.MoveAddressToVpcInput, ...func(*ec2.Options)) (*ec2.MoveAddressToVpcOutput, error)) *EC2_MoveAddressToVpc_Call {
	_c.Call.Return(run)
	return _c
}

// MoveByoipCidrToIpam provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) MoveByoipCidrToIpam(ctx context.Context, params *ec2.MoveByoipCidrToIpamInput, optFns ...func(*ec2.Options)) (*ec2.MoveByoipCidrToIpamOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for MoveByoipCidrToIpam")
	}

	var r0 *ec2.MoveByoipCidrToIpamOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MoveByoipCidrToIpamInput, ...func(*ec2.Options)) (*ec2.MoveByoipCidrToIpamOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MoveByoipCidrToIpamInput, ...func(*ec2.Options)) *ec2.MoveByoipCidrToIpamOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.MoveByoipCidrToIpamOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.MoveByoipCidrToIpamInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_MoveByoipCidrToIpam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MoveByoipCidrToIpam'
type EC2_MoveByoipCidrToIpam_Call struct {
	*mock.Call
}

// MoveByoipCidrToIpam is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.MoveByoipCidrToIpamInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) MoveByoipCidrToIpam(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_MoveByoipCidrToIpam_Call {
	return &EC2_MoveByoipCidrToIpam_Call{Call: _e.mock.On("MoveByoipCidrToIpam",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_MoveByoipCidrToIpam_Call) Run(run func(ctx context.Context, params *ec2.MoveByoipCidrToIpamInput, optFns ...func(*ec2.Options))) *EC2_MoveByoipCidrToIpam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.MoveByoipCidrToIpamInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_MoveByoipCidrToIpam_Call) Return(_a0 *ec2.MoveByoipCidrToIpamOutput, _a1 error) *EC2_MoveByoipCidrToIpam_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_MoveByoipCidrToIpam_Call) RunAndReturn(run func(context.Context, *ec2.MoveByoipCidrToIpamInput, ...func(*ec2.Options)) (*ec2.MoveByoipCidrToIpamOutput, error)) *EC2_MoveByoipCidrToIpam_Call {
	_c.Call.Return(run)
	return _c
}

// MoveCapacityReservationInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) MoveCapacityReservationInstances(ctx context.Context, params *ec2.MoveCapacityReservationInstancesInput, optFns ...func(*ec2.Options)) (*ec2.MoveCapacityReservationInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for MoveCapacityReservationInstances")
	}

	var r0 *ec2.MoveCapacityReservationInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MoveCapacityReservationInstancesInput, ...func(*ec2.Options)) (*ec2.MoveCapacityReservationInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.MoveCapacityReservationInstancesInput, ...func(*ec2.Options)) *ec2.MoveCapacityReservationInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.MoveCapacityReservationInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.MoveCapacityReservationInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_MoveCapacityReservationInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MoveCapacityReservationInstances'
type EC2_MoveCapacityReservationInstances_Call struct {
	*mock.Call
}

// MoveCapacityReservationInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.MoveCapacityReservationInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) MoveCapacityReservationInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_MoveCapacityReservationInstances_Call {
	return &EC2_MoveCapacityReservationInstances_Call{Call: _e.mock.On("MoveCapacityReservationInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_MoveCapacityReservationInstances_Call) Run(run func(ctx context.Context, params *ec2.MoveCapacityReservationInstancesInput, optFns ...func(*ec2.Options))) *EC2_MoveCapacityReservationInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.MoveCapacityReservationInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_MoveCapacityReservationInstances_Call) Return(_a0 *ec2.MoveCapacityReservationInstancesOutput, _a1 error) *EC2_MoveCapacityReservationInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_MoveCapacityReservationInstances_Call) RunAndReturn(run func(context.Context, *ec2.MoveCapacityReservationInstancesInput, ...func(*ec2.Options)) (*ec2.MoveCapacityReservationInstancesOutput, error)) *EC2_MoveCapacityReservationInstances_Call {
	_c.Call.Return(run)
	return _c
}

// Options provides a mock function with no fields
func (_m *EC2) Options() ec2.Options {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Options")
	}

	var r0 ec2.Options
	if rf, ok := ret.Get(0).(func() ec2.Options); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(ec2.Options)
	}

	return r0
}

// EC2_Options_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Options'
type EC2_Options_Call struct {
	*mock.Call
}

// Options is a helper method to define mock.On call
func (_e *EC2_Expecter) Options() *EC2_Options_Call {
	return &EC2_Options_Call{Call: _e.mock.On("Options")}
}

func (_c *EC2_Options_Call) Run(run func()) *EC2_Options_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *EC2_Options_Call) Return(_a0 ec2.Options) *EC2_Options_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EC2_Options_Call) RunAndReturn(run func() ec2.Options) *EC2_Options_Call {
	_c.Call.Return(run)
	return _c
}

// ProvisionByoipCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ProvisionByoipCidr(ctx context.Context, params *ec2.ProvisionByoipCidrInput, optFns ...func(*ec2.Options)) (*ec2.ProvisionByoipCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ProvisionByoipCidr")
	}

	var r0 *ec2.ProvisionByoipCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionByoipCidrInput, ...func(*ec2.Options)) (*ec2.ProvisionByoipCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionByoipCidrInput, ...func(*ec2.Options)) *ec2.ProvisionByoipCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ProvisionByoipCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ProvisionByoipCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ProvisionByoipCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProvisionByoipCidr'
type EC2_ProvisionByoipCidr_Call struct {
	*mock.Call
}

// ProvisionByoipCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ProvisionByoipCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ProvisionByoipCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ProvisionByoipCidr_Call {
	return &EC2_ProvisionByoipCidr_Call{Call: _e.mock.On("ProvisionByoipCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ProvisionByoipCidr_Call) Run(run func(ctx context.Context, params *ec2.ProvisionByoipCidrInput, optFns ...func(*ec2.Options))) *EC2_ProvisionByoipCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ProvisionByoipCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ProvisionByoipCidr_Call) Return(_a0 *ec2.ProvisionByoipCidrOutput, _a1 error) *EC2_ProvisionByoipCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ProvisionByoipCidr_Call) RunAndReturn(run func(context.Context, *ec2.ProvisionByoipCidrInput, ...func(*ec2.Options)) (*ec2.ProvisionByoipCidrOutput, error)) *EC2_ProvisionByoipCidr_Call {
	_c.Call.Return(run)
	return _c
}

// ProvisionIpamByoasn provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ProvisionIpamByoasn(ctx context.Context, params *ec2.ProvisionIpamByoasnInput, optFns ...func(*ec2.Options)) (*ec2.ProvisionIpamByoasnOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ProvisionIpamByoasn")
	}

	var r0 *ec2.ProvisionIpamByoasnOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionIpamByoasnInput, ...func(*ec2.Options)) (*ec2.ProvisionIpamByoasnOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionIpamByoasnInput, ...func(*ec2.Options)) *ec2.ProvisionIpamByoasnOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ProvisionIpamByoasnOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ProvisionIpamByoasnInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ProvisionIpamByoasn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProvisionIpamByoasn'
type EC2_ProvisionIpamByoasn_Call struct {
	*mock.Call
}

// ProvisionIpamByoasn is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ProvisionIpamByoasnInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ProvisionIpamByoasn(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ProvisionIpamByoasn_Call {
	return &EC2_ProvisionIpamByoasn_Call{Call: _e.mock.On("ProvisionIpamByoasn",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ProvisionIpamByoasn_Call) Run(run func(ctx context.Context, params *ec2.ProvisionIpamByoasnInput, optFns ...func(*ec2.Options))) *EC2_ProvisionIpamByoasn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ProvisionIpamByoasnInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ProvisionIpamByoasn_Call) Return(_a0 *ec2.ProvisionIpamByoasnOutput, _a1 error) *EC2_ProvisionIpamByoasn_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ProvisionIpamByoasn_Call) RunAndReturn(run func(context.Context, *ec2.ProvisionIpamByoasnInput, ...func(*ec2.Options)) (*ec2.ProvisionIpamByoasnOutput, error)) *EC2_ProvisionIpamByoasn_Call {
	_c.Call.Return(run)
	return _c
}

// ProvisionIpamPoolCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ProvisionIpamPoolCidr(ctx context.Context, params *ec2.ProvisionIpamPoolCidrInput, optFns ...func(*ec2.Options)) (*ec2.ProvisionIpamPoolCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ProvisionIpamPoolCidr")
	}

	var r0 *ec2.ProvisionIpamPoolCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionIpamPoolCidrInput, ...func(*ec2.Options)) (*ec2.ProvisionIpamPoolCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionIpamPoolCidrInput, ...func(*ec2.Options)) *ec2.ProvisionIpamPoolCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ProvisionIpamPoolCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ProvisionIpamPoolCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ProvisionIpamPoolCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProvisionIpamPoolCidr'
type EC2_ProvisionIpamPoolCidr_Call struct {
	*mock.Call
}

// ProvisionIpamPoolCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ProvisionIpamPoolCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ProvisionIpamPoolCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ProvisionIpamPoolCidr_Call {
	return &EC2_ProvisionIpamPoolCidr_Call{Call: _e.mock.On("ProvisionIpamPoolCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ProvisionIpamPoolCidr_Call) Run(run func(ctx context.Context, params *ec2.ProvisionIpamPoolCidrInput, optFns ...func(*ec2.Options))) *EC2_ProvisionIpamPoolCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ProvisionIpamPoolCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ProvisionIpamPoolCidr_Call) Return(_a0 *ec2.ProvisionIpamPoolCidrOutput, _a1 error) *EC2_ProvisionIpamPoolCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ProvisionIpamPoolCidr_Call) RunAndReturn(run func(context.Context, *ec2.ProvisionIpamPoolCidrInput, ...func(*ec2.Options)) (*ec2.ProvisionIpamPoolCidrOutput, error)) *EC2_ProvisionIpamPoolCidr_Call {
	_c.Call.Return(run)
	return _c
}

// ProvisionPublicIpv4PoolCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ProvisionPublicIpv4PoolCidr(ctx context.Context, params *ec2.ProvisionPublicIpv4PoolCidrInput, optFns ...func(*ec2.Options)) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ProvisionPublicIpv4PoolCidr")
	}

	var r0 *ec2.ProvisionPublicIpv4PoolCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionPublicIpv4PoolCidrInput, ...func(*ec2.Options)) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ProvisionPublicIpv4PoolCidrInput, ...func(*ec2.Options)) *ec2.ProvisionPublicIpv4PoolCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ProvisionPublicIpv4PoolCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ProvisionPublicIpv4PoolCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ProvisionPublicIpv4PoolCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProvisionPublicIpv4PoolCidr'
type EC2_ProvisionPublicIpv4PoolCidr_Call struct {
	*mock.Call
}

// ProvisionPublicIpv4PoolCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ProvisionPublicIpv4PoolCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ProvisionPublicIpv4PoolCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ProvisionPublicIpv4PoolCidr_Call {
	return &EC2_ProvisionPublicIpv4PoolCidr_Call{Call: _e.mock.On("ProvisionPublicIpv4PoolCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ProvisionPublicIpv4PoolCidr_Call) Run(run func(ctx context.Context, params *ec2.ProvisionPublicIpv4PoolCidrInput, optFns ...func(*ec2.Options))) *EC2_ProvisionPublicIpv4PoolCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ProvisionPublicIpv4PoolCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ProvisionPublicIpv4PoolCidr_Call) Return(_a0 *ec2.ProvisionPublicIpv4PoolCidrOutput, _a1 error) *EC2_ProvisionPublicIpv4PoolCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ProvisionPublicIpv4PoolCidr_Call) RunAndReturn(run func(context.Context, *ec2.ProvisionPublicIpv4PoolCidrInput, ...func(*ec2.Options)) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error)) *EC2_ProvisionPublicIpv4PoolCidr_Call {
	_c.Call.Return(run)
	return _c
}

// PurchaseCapacityBlock provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) PurchaseCapacityBlock(ctx context.Context, params *ec2.PurchaseCapacityBlockInput, optFns ...func(*ec2.Options)) (*ec2.PurchaseCapacityBlockOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PurchaseCapacityBlock")
	}

	var r0 *ec2.PurchaseCapacityBlockOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseCapacityBlockInput, ...func(*ec2.Options)) (*ec2.PurchaseCapacityBlockOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseCapacityBlockInput, ...func(*ec2.Options)) *ec2.PurchaseCapacityBlockOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseCapacityBlockOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.PurchaseCapacityBlockInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_PurchaseCapacityBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseCapacityBlock'
type EC2_PurchaseCapacityBlock_Call struct {
	*mock.Call
}

// PurchaseCapacityBlock is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.PurchaseCapacityBlockInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) PurchaseCapacityBlock(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_PurchaseCapacityBlock_Call {
	return &EC2_PurchaseCapacityBlock_Call{Call: _e.mock.On("PurchaseCapacityBlock",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_PurchaseCapacityBlock_Call) Run(run func(ctx context.Context, params *ec2.PurchaseCapacityBlockInput, optFns ...func(*ec2.Options))) *EC2_PurchaseCapacityBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.PurchaseCapacityBlockInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_PurchaseCapacityBlock_Call) Return(_a0 *ec2.PurchaseCapacityBlockOutput, _a1 error) *EC2_PurchaseCapacityBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_PurchaseCapacityBlock_Call) RunAndReturn(run func(context.Context, *ec2.PurchaseCapacityBlockInput, ...func(*ec2.Options)) (*ec2.PurchaseCapacityBlockOutput, error)) *EC2_PurchaseCapacityBlock_Call {
	_c.Call.Return(run)
	return _c
}

// PurchaseCapacityBlockExtension provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) PurchaseCapacityBlockExtension(ctx context.Context, params *ec2.PurchaseCapacityBlockExtensionInput, optFns ...func(*ec2.Options)) (*ec2.PurchaseCapacityBlockExtensionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PurchaseCapacityBlockExtension")
	}

	var r0 *ec2.PurchaseCapacityBlockExtensionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseCapacityBlockExtensionInput, ...func(*ec2.Options)) (*ec2.PurchaseCapacityBlockExtensionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseCapacityBlockExtensionInput, ...func(*ec2.Options)) *ec2.PurchaseCapacityBlockExtensionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseCapacityBlockExtensionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.PurchaseCapacityBlockExtensionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_PurchaseCapacityBlockExtension_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseCapacityBlockExtension'
type EC2_PurchaseCapacityBlockExtension_Call struct {
	*mock.Call
}

// PurchaseCapacityBlockExtension is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.PurchaseCapacityBlockExtensionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) PurchaseCapacityBlockExtension(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_PurchaseCapacityBlockExtension_Call {
	return &EC2_PurchaseCapacityBlockExtension_Call{Call: _e.mock.On("PurchaseCapacityBlockExtension",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_PurchaseCapacityBlockExtension_Call) Run(run func(ctx context.Context, params *ec2.PurchaseCapacityBlockExtensionInput, optFns ...func(*ec2.Options))) *EC2_PurchaseCapacityBlockExtension_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.PurchaseCapacityBlockExtensionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_PurchaseCapacityBlockExtension_Call) Return(_a0 *ec2.PurchaseCapacityBlockExtensionOutput, _a1 error) *EC2_PurchaseCapacityBlockExtension_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_PurchaseCapacityBlockExtension_Call) RunAndReturn(run func(context.Context, *ec2.PurchaseCapacityBlockExtensionInput, ...func(*ec2.Options)) (*ec2.PurchaseCapacityBlockExtensionOutput, error)) *EC2_PurchaseCapacityBlockExtension_Call {
	_c.Call.Return(run)
	return _c
}

// PurchaseHostReservation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) PurchaseHostReservation(ctx context.Context, params *ec2.PurchaseHostReservationInput, optFns ...func(*ec2.Options)) (*ec2.PurchaseHostReservationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PurchaseHostReservation")
	}

	var r0 *ec2.PurchaseHostReservationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseHostReservationInput, ...func(*ec2.Options)) (*ec2.PurchaseHostReservationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseHostReservationInput, ...func(*ec2.Options)) *ec2.PurchaseHostReservationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseHostReservationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.PurchaseHostReservationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_PurchaseHostReservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseHostReservation'
type EC2_PurchaseHostReservation_Call struct {
	*mock.Call
}

// PurchaseHostReservation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.PurchaseHostReservationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) PurchaseHostReservation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_PurchaseHostReservation_Call {
	return &EC2_PurchaseHostReservation_Call{Call: _e.mock.On("PurchaseHostReservation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_PurchaseHostReservation_Call) Run(run func(ctx context.Context, params *ec2.PurchaseHostReservationInput, optFns ...func(*ec2.Options))) *EC2_PurchaseHostReservation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.PurchaseHostReservationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_PurchaseHostReservation_Call) Return(_a0 *ec2.PurchaseHostReservationOutput, _a1 error) *EC2_PurchaseHostReservation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_PurchaseHostReservation_Call) RunAndReturn(run func(context.Context, *ec2.PurchaseHostReservationInput, ...func(*ec2.Options)) (*ec2.PurchaseHostReservationOutput, error)) *EC2_PurchaseHostReservation_Call {
	_c.Call.Return(run)
	return _c
}

// PurchaseReservedInstancesOffering provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) PurchaseReservedInstancesOffering(ctx context.Context, params *ec2.PurchaseReservedInstancesOfferingInput, optFns ...func(*ec2.Options)) (*ec2.PurchaseReservedInstancesOfferingOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PurchaseReservedInstancesOffering")
	}

	var r0 *ec2.PurchaseReservedInstancesOfferingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseReservedInstancesOfferingInput, ...func(*ec2.Options)) (*ec2.PurchaseReservedInstancesOfferingOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseReservedInstancesOfferingInput, ...func(*ec2.Options)) *ec2.PurchaseReservedInstancesOfferingOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseReservedInstancesOfferingOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.PurchaseReservedInstancesOfferingInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_PurchaseReservedInstancesOffering_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseReservedInstancesOffering'
type EC2_PurchaseReservedInstancesOffering_Call struct {
	*mock.Call
}

// PurchaseReservedInstancesOffering is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.PurchaseReservedInstancesOfferingInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) PurchaseReservedInstancesOffering(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_PurchaseReservedInstancesOffering_Call {
	return &EC2_PurchaseReservedInstancesOffering_Call{Call: _e.mock.On("PurchaseReservedInstancesOffering",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_PurchaseReservedInstancesOffering_Call) Run(run func(ctx context.Context, params *ec2.PurchaseReservedInstancesOfferingInput, optFns ...func(*ec2.Options))) *EC2_PurchaseReservedInstancesOffering_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.PurchaseReservedInstancesOfferingInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_PurchaseReservedInstancesOffering_Call) Return(_a0 *ec2.PurchaseReservedInstancesOfferingOutput, _a1 error) *EC2_PurchaseReservedInstancesOffering_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_PurchaseReservedInstancesOffering_Call) RunAndReturn(run func(context.Context, *ec2.PurchaseReservedInstancesOfferingInput, ...func(*ec2.Options)) (*ec2.PurchaseReservedInstancesOfferingOutput, error)) *EC2_PurchaseReservedInstancesOffering_Call {
	_c.Call.Return(run)
	return _c
}

// PurchaseScheduledInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) PurchaseScheduledInstances(ctx context.Context, params *ec2.PurchaseScheduledInstancesInput, optFns ...func(*ec2.Options)) (*ec2.PurchaseScheduledInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PurchaseScheduledInstances")
	}

	var r0 *ec2.PurchaseScheduledInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseScheduledInstancesInput, ...func(*ec2.Options)) (*ec2.PurchaseScheduledInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.PurchaseScheduledInstancesInput, ...func(*ec2.Options)) *ec2.PurchaseScheduledInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.PurchaseScheduledInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.PurchaseScheduledInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_PurchaseScheduledInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurchaseScheduledInstances'
type EC2_PurchaseScheduledInstances_Call struct {
	*mock.Call
}

// PurchaseScheduledInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.PurchaseScheduledInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) PurchaseScheduledInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_PurchaseScheduledInstances_Call {
	return &EC2_PurchaseScheduledInstances_Call{Call: _e.mock.On("PurchaseScheduledInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_PurchaseScheduledInstances_Call) Run(run func(ctx context.Context, params *ec2.PurchaseScheduledInstancesInput, optFns ...func(*ec2.Options))) *EC2_PurchaseScheduledInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.PurchaseScheduledInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_PurchaseScheduledInstances_Call) Return(_a0 *ec2.PurchaseScheduledInstancesOutput, _a1 error) *EC2_PurchaseScheduledInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_PurchaseScheduledInstances_Call) RunAndReturn(run func(context.Context, *ec2.PurchaseScheduledInstancesInput, ...func(*ec2.Options)) (*ec2.PurchaseScheduledInstancesOutput, error)) *EC2_PurchaseScheduledInstances_Call {
	_c.Call.Return(run)
	return _c
}

// RebootInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RebootInstances(ctx context.Context, params *ec2.RebootInstancesInput, optFns ...func(*ec2.Options)) (*ec2.RebootInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RebootInstances")
	}

	var r0 *ec2.RebootInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RebootInstancesInput, ...func(*ec2.Options)) (*ec2.RebootInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RebootInstancesInput, ...func(*ec2.Options)) *ec2.RebootInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RebootInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RebootInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RebootInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RebootInstances'
type EC2_RebootInstances_Call struct {
	*mock.Call
}

// RebootInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RebootInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RebootInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RebootInstances_Call {
	return &EC2_RebootInstances_Call{Call: _e.mock.On("RebootInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RebootInstances_Call) Run(run func(ctx context.Context, params *ec2.RebootInstancesInput, optFns ...func(*ec2.Options))) *EC2_RebootInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RebootInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RebootInstances_Call) Return(_a0 *ec2.RebootInstancesOutput, _a1 error) *EC2_RebootInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RebootInstances_Call) RunAndReturn(run func(context.Context, *ec2.RebootInstancesInput, ...func(*ec2.Options)) (*ec2.RebootInstancesOutput, error)) *EC2_RebootInstances_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterImage provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RegisterImage(ctx context.Context, params *ec2.RegisterImageInput, optFns ...func(*ec2.Options)) (*ec2.RegisterImageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RegisterImage")
	}

	var r0 *ec2.RegisterImageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterImageInput, ...func(*ec2.Options)) (*ec2.RegisterImageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterImageInput, ...func(*ec2.Options)) *ec2.RegisterImageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterImageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RegisterImageInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RegisterImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterImage'
type EC2_RegisterImage_Call struct {
	*mock.Call
}

// RegisterImage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RegisterImageInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RegisterImage(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RegisterImage_Call {
	return &EC2_RegisterImage_Call{Call: _e.mock.On("RegisterImage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RegisterImage_Call) Run(run func(ctx context.Context, params *ec2.RegisterImageInput, optFns ...func(*ec2.Options))) *EC2_RegisterImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RegisterImageInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RegisterImage_Call) Return(_a0 *ec2.RegisterImageOutput, _a1 error) *EC2_RegisterImage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RegisterImage_Call) RunAndReturn(run func(context.Context, *ec2.RegisterImageInput, ...func(*ec2.Options)) (*ec2.RegisterImageOutput, error)) *EC2_RegisterImage_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterInstanceEventNotificationAttributes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RegisterInstanceEventNotificationAttributes(ctx context.Context, params *ec2.RegisterInstanceEventNotificationAttributesInput, optFns ...func(*ec2.Options)) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RegisterInstanceEventNotificationAttributes")
	}

	var r0 *ec2.RegisterInstanceEventNotificationAttributesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) *ec2.RegisterInstanceEventNotificationAttributesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterInstanceEventNotificationAttributesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RegisterInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RegisterInstanceEventNotificationAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterInstanceEventNotificationAttributes'
type EC2_RegisterInstanceEventNotificationAttributes_Call struct {
	*mock.Call
}

// RegisterInstanceEventNotificationAttributes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RegisterInstanceEventNotificationAttributesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RegisterInstanceEventNotificationAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RegisterInstanceEventNotificationAttributes_Call {
	return &EC2_RegisterInstanceEventNotificationAttributes_Call{Call: _e.mock.On("RegisterInstanceEventNotificationAttributes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RegisterInstanceEventNotificationAttributes_Call) Run(run func(ctx context.Context, params *ec2.RegisterInstanceEventNotificationAttributesInput, optFns ...func(*ec2.Options))) *EC2_RegisterInstanceEventNotificationAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RegisterInstanceEventNotificationAttributesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RegisterInstanceEventNotificationAttributes_Call) Return(_a0 *ec2.RegisterInstanceEventNotificationAttributesOutput, _a1 error) *EC2_RegisterInstanceEventNotificationAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RegisterInstanceEventNotificationAttributes_Call) RunAndReturn(run func(context.Context, *ec2.RegisterInstanceEventNotificationAttributesInput, ...func(*ec2.Options)) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error)) *EC2_RegisterInstanceEventNotificationAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterTransitGatewayMulticastGroupMembers provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RegisterTransitGatewayMulticastGroupMembers(ctx context.Context, params *ec2.RegisterTransitGatewayMulticastGroupMembersInput, optFns ...func(*ec2.Options)) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RegisterTransitGatewayMulticastGroupMembers")
	}

	var r0 *ec2.RegisterTransitGatewayMulticastGroupMembersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupMembersInput, ...func(*ec2.Options)) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupMembersInput, ...func(*ec2.Options)) *ec2.RegisterTransitGatewayMulticastGroupMembersOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupMembersInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RegisterTransitGatewayMulticastGroupMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterTransitGatewayMulticastGroupMembers'
type EC2_RegisterTransitGatewayMulticastGroupMembers_Call struct {
	*mock.Call
}

// RegisterTransitGatewayMulticastGroupMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RegisterTransitGatewayMulticastGroupMembersInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RegisterTransitGatewayMulticastGroupMembers(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RegisterTransitGatewayMulticastGroupMembers_Call {
	return &EC2_RegisterTransitGatewayMulticastGroupMembers_Call{Call: _e.mock.On("RegisterTransitGatewayMulticastGroupMembers",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RegisterTransitGatewayMulticastGroupMembers_Call) Run(run func(ctx context.Context, params *ec2.RegisterTransitGatewayMulticastGroupMembersInput, optFns ...func(*ec2.Options))) *EC2_RegisterTransitGatewayMulticastGroupMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RegisterTransitGatewayMulticastGroupMembersInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RegisterTransitGatewayMulticastGroupMembers_Call) Return(_a0 *ec2.RegisterTransitGatewayMulticastGroupMembersOutput, _a1 error) *EC2_RegisterTransitGatewayMulticastGroupMembers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RegisterTransitGatewayMulticastGroupMembers_Call) RunAndReturn(run func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupMembersInput, ...func(*ec2.Options)) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error)) *EC2_RegisterTransitGatewayMulticastGroupMembers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterTransitGatewayMulticastGroupSources provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RegisterTransitGatewayMulticastGroupSources(ctx context.Context, params *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, optFns ...func(*ec2.Options)) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RegisterTransitGatewayMulticastGroupSources")
	}

	var r0 *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, ...func(*ec2.Options)) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, ...func(*ec2.Options)) *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RegisterTransitGatewayMulticastGroupSources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterTransitGatewayMulticastGroupSources'
type EC2_RegisterTransitGatewayMulticastGroupSources_Call struct {
	*mock.Call
}

// RegisterTransitGatewayMulticastGroupSources is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RegisterTransitGatewayMulticastGroupSourcesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RegisterTransitGatewayMulticastGroupSources(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RegisterTransitGatewayMulticastGroupSources_Call {
	return &EC2_RegisterTransitGatewayMulticastGroupSources_Call{Call: _e.mock.On("RegisterTransitGatewayMulticastGroupSources",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RegisterTransitGatewayMulticastGroupSources_Call) Run(run func(ctx context.Context, params *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, optFns ...func(*ec2.Options))) *EC2_RegisterTransitGatewayMulticastGroupSources_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RegisterTransitGatewayMulticastGroupSourcesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RegisterTransitGatewayMulticastGroupSources_Call) Return(_a0 *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, _a1 error) *EC2_RegisterTransitGatewayMulticastGroupSources_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RegisterTransitGatewayMulticastGroupSources_Call) RunAndReturn(run func(context.Context, *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, ...func(*ec2.Options)) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error)) *EC2_RegisterTransitGatewayMulticastGroupSources_Call {
	_c.Call.Return(run)
	return _c
}

// RejectCapacityReservationBillingOwnership provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RejectCapacityReservationBillingOwnership(ctx context.Context, params *ec2.RejectCapacityReservationBillingOwnershipInput, optFns ...func(*ec2.Options)) (*ec2.RejectCapacityReservationBillingOwnershipOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RejectCapacityReservationBillingOwnership")
	}

	var r0 *ec2.RejectCapacityReservationBillingOwnershipOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectCapacityReservationBillingOwnershipInput, ...func(*ec2.Options)) (*ec2.RejectCapacityReservationBillingOwnershipOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectCapacityReservationBillingOwnershipInput, ...func(*ec2.Options)) *ec2.RejectCapacityReservationBillingOwnershipOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectCapacityReservationBillingOwnershipOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectCapacityReservationBillingOwnershipInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RejectCapacityReservationBillingOwnership_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectCapacityReservationBillingOwnership'
type EC2_RejectCapacityReservationBillingOwnership_Call struct {
	*mock.Call
}

// RejectCapacityReservationBillingOwnership is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RejectCapacityReservationBillingOwnershipInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RejectCapacityReservationBillingOwnership(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RejectCapacityReservationBillingOwnership_Call {
	return &EC2_RejectCapacityReservationBillingOwnership_Call{Call: _e.mock.On("RejectCapacityReservationBillingOwnership",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RejectCapacityReservationBillingOwnership_Call) Run(run func(ctx context.Context, params *ec2.RejectCapacityReservationBillingOwnershipInput, optFns ...func(*ec2.Options))) *EC2_RejectCapacityReservationBillingOwnership_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RejectCapacityReservationBillingOwnershipInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RejectCapacityReservationBillingOwnership_Call) Return(_a0 *ec2.RejectCapacityReservationBillingOwnershipOutput, _a1 error) *EC2_RejectCapacityReservationBillingOwnership_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RejectCapacityReservationBillingOwnership_Call) RunAndReturn(run func(context.Context, *ec2.RejectCapacityReservationBillingOwnershipInput, ...func(*ec2.Options)) (*ec2.RejectCapacityReservationBillingOwnershipOutput, error)) *EC2_RejectCapacityReservationBillingOwnership_Call {
	_c.Call.Return(run)
	return _c
}

// RejectTransitGatewayMulticastDomainAssociations provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RejectTransitGatewayMulticastDomainAssociations(ctx context.Context, params *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, optFns ...func(*ec2.Options)) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RejectTransitGatewayMulticastDomainAssociations")
	}

	var r0 *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RejectTransitGatewayMulticastDomainAssociations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectTransitGatewayMulticastDomainAssociations'
type EC2_RejectTransitGatewayMulticastDomainAssociations_Call struct {
	*mock.Call
}

// RejectTransitGatewayMulticastDomainAssociations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RejectTransitGatewayMulticastDomainAssociationsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RejectTransitGatewayMulticastDomainAssociations(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RejectTransitGatewayMulticastDomainAssociations_Call {
	return &EC2_RejectTransitGatewayMulticastDomainAssociations_Call{Call: _e.mock.On("RejectTransitGatewayMulticastDomainAssociations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RejectTransitGatewayMulticastDomainAssociations_Call) Run(run func(ctx context.Context, params *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, optFns ...func(*ec2.Options))) *EC2_RejectTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RejectTransitGatewayMulticastDomainAssociationsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RejectTransitGatewayMulticastDomainAssociations_Call) Return(_a0 *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, _a1 error) *EC2_RejectTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RejectTransitGatewayMulticastDomainAssociations_Call) RunAndReturn(run func(context.Context, *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, ...func(*ec2.Options)) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error)) *EC2_RejectTransitGatewayMulticastDomainAssociations_Call {
	_c.Call.Return(run)
	return _c
}

// RejectTransitGatewayPeeringAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RejectTransitGatewayPeeringAttachment(ctx context.Context, params *ec2.RejectTransitGatewayPeeringAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RejectTransitGatewayPeeringAttachment")
	}

	var r0 *ec2.RejectTransitGatewayPeeringAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) *ec2.RejectTransitGatewayPeeringAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RejectTransitGatewayPeeringAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectTransitGatewayPeeringAttachment'
type EC2_RejectTransitGatewayPeeringAttachment_Call struct {
	*mock.Call
}

// RejectTransitGatewayPeeringAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RejectTransitGatewayPeeringAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RejectTransitGatewayPeeringAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RejectTransitGatewayPeeringAttachment_Call {
	return &EC2_RejectTransitGatewayPeeringAttachment_Call{Call: _e.mock.On("RejectTransitGatewayPeeringAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RejectTransitGatewayPeeringAttachment_Call) Run(run func(ctx context.Context, params *ec2.RejectTransitGatewayPeeringAttachmentInput, optFns ...func(*ec2.Options))) *EC2_RejectTransitGatewayPeeringAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RejectTransitGatewayPeeringAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RejectTransitGatewayPeeringAttachment_Call) Return(_a0 *ec2.RejectTransitGatewayPeeringAttachmentOutput, _a1 error) *EC2_RejectTransitGatewayPeeringAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RejectTransitGatewayPeeringAttachment_Call) RunAndReturn(run func(context.Context, *ec2.RejectTransitGatewayPeeringAttachmentInput, ...func(*ec2.Options)) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error)) *EC2_RejectTransitGatewayPeeringAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// RejectTransitGatewayVpcAttachment provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RejectTransitGatewayVpcAttachment(ctx context.Context, params *ec2.RejectTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options)) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RejectTransitGatewayVpcAttachment")
	}

	var r0 *ec2.RejectTransitGatewayVpcAttachmentOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) *ec2.RejectTransitGatewayVpcAttachmentOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectTransitGatewayVpcAttachmentOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RejectTransitGatewayVpcAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectTransitGatewayVpcAttachment'
type EC2_RejectTransitGatewayVpcAttachment_Call struct {
	*mock.Call
}

// RejectTransitGatewayVpcAttachment is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RejectTransitGatewayVpcAttachmentInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RejectTransitGatewayVpcAttachment(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RejectTransitGatewayVpcAttachment_Call {
	return &EC2_RejectTransitGatewayVpcAttachment_Call{Call: _e.mock.On("RejectTransitGatewayVpcAttachment",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RejectTransitGatewayVpcAttachment_Call) Run(run func(ctx context.Context, params *ec2.RejectTransitGatewayVpcAttachmentInput, optFns ...func(*ec2.Options))) *EC2_RejectTransitGatewayVpcAttachment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RejectTransitGatewayVpcAttachmentInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RejectTransitGatewayVpcAttachment_Call) Return(_a0 *ec2.RejectTransitGatewayVpcAttachmentOutput, _a1 error) *EC2_RejectTransitGatewayVpcAttachment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RejectTransitGatewayVpcAttachment_Call) RunAndReturn(run func(context.Context, *ec2.RejectTransitGatewayVpcAttachmentInput, ...func(*ec2.Options)) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error)) *EC2_RejectTransitGatewayVpcAttachment_Call {
	_c.Call.Return(run)
	return _c
}

// RejectVpcEndpointConnections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RejectVpcEndpointConnections(ctx context.Context, params *ec2.RejectVpcEndpointConnectionsInput, optFns ...func(*ec2.Options)) (*ec2.RejectVpcEndpointConnectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RejectVpcEndpointConnections")
	}

	var r0 *ec2.RejectVpcEndpointConnectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectVpcEndpointConnectionsInput, ...func(*ec2.Options)) (*ec2.RejectVpcEndpointConnectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectVpcEndpointConnectionsInput, ...func(*ec2.Options)) *ec2.RejectVpcEndpointConnectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectVpcEndpointConnectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectVpcEndpointConnectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RejectVpcEndpointConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectVpcEndpointConnections'
type EC2_RejectVpcEndpointConnections_Call struct {
	*mock.Call
}

// RejectVpcEndpointConnections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RejectVpcEndpointConnectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RejectVpcEndpointConnections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RejectVpcEndpointConnections_Call {
	return &EC2_RejectVpcEndpointConnections_Call{Call: _e.mock.On("RejectVpcEndpointConnections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RejectVpcEndpointConnections_Call) Run(run func(ctx context.Context, params *ec2.RejectVpcEndpointConnectionsInput, optFns ...func(*ec2.Options))) *EC2_RejectVpcEndpointConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RejectVpcEndpointConnectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RejectVpcEndpointConnections_Call) Return(_a0 *ec2.RejectVpcEndpointConnectionsOutput, _a1 error) *EC2_RejectVpcEndpointConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RejectVpcEndpointConnections_Call) RunAndReturn(run func(context.Context, *ec2.RejectVpcEndpointConnectionsInput, ...func(*ec2.Options)) (*ec2.RejectVpcEndpointConnectionsOutput, error)) *EC2_RejectVpcEndpointConnections_Call {
	_c.Call.Return(run)
	return _c
}

// RejectVpcPeeringConnection provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RejectVpcPeeringConnection(ctx context.Context, params *ec2.RejectVpcPeeringConnectionInput, optFns ...func(*ec2.Options)) (*ec2.RejectVpcPeeringConnectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RejectVpcPeeringConnection")
	}

	var r0 *ec2.RejectVpcPeeringConnectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectVpcPeeringConnectionInput, ...func(*ec2.Options)) (*ec2.RejectVpcPeeringConnectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RejectVpcPeeringConnectionInput, ...func(*ec2.Options)) *ec2.RejectVpcPeeringConnectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RejectVpcPeeringConnectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RejectVpcPeeringConnectionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RejectVpcPeeringConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectVpcPeeringConnection'
type EC2_RejectVpcPeeringConnection_Call struct {
	*mock.Call
}

// RejectVpcPeeringConnection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RejectVpcPeeringConnectionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RejectVpcPeeringConnection(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RejectVpcPeeringConnection_Call {
	return &EC2_RejectVpcPeeringConnection_Call{Call: _e.mock.On("RejectVpcPeeringConnection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RejectVpcPeeringConnection_Call) Run(run func(ctx context.Context, params *ec2.RejectVpcPeeringConnectionInput, optFns ...func(*ec2.Options))) *EC2_RejectVpcPeeringConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RejectVpcPeeringConnectionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RejectVpcPeeringConnection_Call) Return(_a0 *ec2.RejectVpcPeeringConnectionOutput, _a1 error) *EC2_RejectVpcPeeringConnection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RejectVpcPeeringConnection_Call) RunAndReturn(run func(context.Context, *ec2.RejectVpcPeeringConnectionInput, ...func(*ec2.Options)) (*ec2.RejectVpcPeeringConnectionOutput, error)) *EC2_RejectVpcPeeringConnection_Call {
	_c.Call.Return(run)
	return _c
}

// ReleaseAddress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReleaseAddress(ctx context.Context, params *ec2.ReleaseAddressInput, optFns ...func(*ec2.Options)) (*ec2.ReleaseAddressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReleaseAddress")
	}

	var r0 *ec2.ReleaseAddressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReleaseAddressInput, ...func(*ec2.Options)) (*ec2.ReleaseAddressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReleaseAddressInput, ...func(*ec2.Options)) *ec2.ReleaseAddressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReleaseAddressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReleaseAddressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReleaseAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseAddress'
type EC2_ReleaseAddress_Call struct {
	*mock.Call
}

// ReleaseAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReleaseAddressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReleaseAddress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReleaseAddress_Call {
	return &EC2_ReleaseAddress_Call{Call: _e.mock.On("ReleaseAddress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReleaseAddress_Call) Run(run func(ctx context.Context, params *ec2.ReleaseAddressInput, optFns ...func(*ec2.Options))) *EC2_ReleaseAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReleaseAddressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReleaseAddress_Call) Return(_a0 *ec2.ReleaseAddressOutput, _a1 error) *EC2_ReleaseAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReleaseAddress_Call) RunAndReturn(run func(context.Context, *ec2.ReleaseAddressInput, ...func(*ec2.Options)) (*ec2.ReleaseAddressOutput, error)) *EC2_ReleaseAddress_Call {
	_c.Call.Return(run)
	return _c
}

// ReleaseHosts provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReleaseHosts(ctx context.Context, params *ec2.ReleaseHostsInput, optFns ...func(*ec2.Options)) (*ec2.ReleaseHostsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReleaseHosts")
	}

	var r0 *ec2.ReleaseHostsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReleaseHostsInput, ...func(*ec2.Options)) (*ec2.ReleaseHostsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReleaseHostsInput, ...func(*ec2.Options)) *ec2.ReleaseHostsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReleaseHostsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReleaseHostsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReleaseHosts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseHosts'
type EC2_ReleaseHosts_Call struct {
	*mock.Call
}

// ReleaseHosts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReleaseHostsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReleaseHosts(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReleaseHosts_Call {
	return &EC2_ReleaseHosts_Call{Call: _e.mock.On("ReleaseHosts",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReleaseHosts_Call) Run(run func(ctx context.Context, params *ec2.ReleaseHostsInput, optFns ...func(*ec2.Options))) *EC2_ReleaseHosts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReleaseHostsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReleaseHosts_Call) Return(_a0 *ec2.ReleaseHostsOutput, _a1 error) *EC2_ReleaseHosts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReleaseHosts_Call) RunAndReturn(run func(context.Context, *ec2.ReleaseHostsInput, ...func(*ec2.Options)) (*ec2.ReleaseHostsOutput, error)) *EC2_ReleaseHosts_Call {
	_c.Call.Return(run)
	return _c
}

// ReleaseIpamPoolAllocation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReleaseIpamPoolAllocation(ctx context.Context, params *ec2.ReleaseIpamPoolAllocationInput, optFns ...func(*ec2.Options)) (*ec2.ReleaseIpamPoolAllocationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReleaseIpamPoolAllocation")
	}

	var r0 *ec2.ReleaseIpamPoolAllocationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReleaseIpamPoolAllocationInput, ...func(*ec2.Options)) (*ec2.ReleaseIpamPoolAllocationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReleaseIpamPoolAllocationInput, ...func(*ec2.Options)) *ec2.ReleaseIpamPoolAllocationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReleaseIpamPoolAllocationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReleaseIpamPoolAllocationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReleaseIpamPoolAllocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseIpamPoolAllocation'
type EC2_ReleaseIpamPoolAllocation_Call struct {
	*mock.Call
}

// ReleaseIpamPoolAllocation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReleaseIpamPoolAllocationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReleaseIpamPoolAllocation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReleaseIpamPoolAllocation_Call {
	return &EC2_ReleaseIpamPoolAllocation_Call{Call: _e.mock.On("ReleaseIpamPoolAllocation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReleaseIpamPoolAllocation_Call) Run(run func(ctx context.Context, params *ec2.ReleaseIpamPoolAllocationInput, optFns ...func(*ec2.Options))) *EC2_ReleaseIpamPoolAllocation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReleaseIpamPoolAllocationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReleaseIpamPoolAllocation_Call) Return(_a0 *ec2.ReleaseIpamPoolAllocationOutput, _a1 error) *EC2_ReleaseIpamPoolAllocation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReleaseIpamPoolAllocation_Call) RunAndReturn(run func(context.Context, *ec2.ReleaseIpamPoolAllocationInput, ...func(*ec2.Options)) (*ec2.ReleaseIpamPoolAllocationOutput, error)) *EC2_ReleaseIpamPoolAllocation_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceIamInstanceProfileAssociation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReplaceIamInstanceProfileAssociation(ctx context.Context, params *ec2.ReplaceIamInstanceProfileAssociationInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReplaceIamInstanceProfileAssociation")
	}

	var r0 *ec2.ReplaceIamInstanceProfileAssociationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceIamInstanceProfileAssociationInput, ...func(*ec2.Options)) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceIamInstanceProfileAssociationInput, ...func(*ec2.Options)) *ec2.ReplaceIamInstanceProfileAssociationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceIamInstanceProfileAssociationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceIamInstanceProfileAssociationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReplaceIamInstanceProfileAssociation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceIamInstanceProfileAssociation'
type EC2_ReplaceIamInstanceProfileAssociation_Call struct {
	*mock.Call
}

// ReplaceIamInstanceProfileAssociation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReplaceIamInstanceProfileAssociationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReplaceIamInstanceProfileAssociation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReplaceIamInstanceProfileAssociation_Call {
	return &EC2_ReplaceIamInstanceProfileAssociation_Call{Call: _e.mock.On("ReplaceIamInstanceProfileAssociation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReplaceIamInstanceProfileAssociation_Call) Run(run func(ctx context.Context, params *ec2.ReplaceIamInstanceProfileAssociationInput, optFns ...func(*ec2.Options))) *EC2_ReplaceIamInstanceProfileAssociation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReplaceIamInstanceProfileAssociationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReplaceIamInstanceProfileAssociation_Call) Return(_a0 *ec2.ReplaceIamInstanceProfileAssociationOutput, _a1 error) *EC2_ReplaceIamInstanceProfileAssociation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReplaceIamInstanceProfileAssociation_Call) RunAndReturn(run func(context.Context, *ec2.ReplaceIamInstanceProfileAssociationInput, ...func(*ec2.Options)) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error)) *EC2_ReplaceIamInstanceProfileAssociation_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceImageCriteriaInAllowedImagesSettings provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReplaceImageCriteriaInAllowedImagesSettings(ctx context.Context, params *ec2.ReplaceImageCriteriaInAllowedImagesSettingsInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceImageCriteriaInAllowedImagesSettingsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReplaceImageCriteriaInAllowedImagesSettings")
	}

	var r0 *ec2.ReplaceImageCriteriaInAllowedImagesSettingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceImageCriteriaInAllowedImagesSettingsInput, ...func(*ec2.Options)) (*ec2.ReplaceImageCriteriaInAllowedImagesSettingsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceImageCriteriaInAllowedImagesSettingsInput, ...func(*ec2.Options)) *ec2.ReplaceImageCriteriaInAllowedImagesSettingsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceImageCriteriaInAllowedImagesSettingsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceImageCriteriaInAllowedImagesSettingsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceImageCriteriaInAllowedImagesSettings'
type EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call struct {
	*mock.Call
}

// ReplaceImageCriteriaInAllowedImagesSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReplaceImageCriteriaInAllowedImagesSettingsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReplaceImageCriteriaInAllowedImagesSettings(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call {
	return &EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call{Call: _e.mock.On("ReplaceImageCriteriaInAllowedImagesSettings",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call) Run(run func(ctx context.Context, params *ec2.ReplaceImageCriteriaInAllowedImagesSettingsInput, optFns ...func(*ec2.Options))) *EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReplaceImageCriteriaInAllowedImagesSettingsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call) Return(_a0 *ec2.ReplaceImageCriteriaInAllowedImagesSettingsOutput, _a1 error) *EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call) RunAndReturn(run func(context.Context, *ec2.ReplaceImageCriteriaInAllowedImagesSettingsInput, ...func(*ec2.Options)) (*ec2.ReplaceImageCriteriaInAllowedImagesSettingsOutput, error)) *EC2_ReplaceImageCriteriaInAllowedImagesSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceNetworkAclAssociation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReplaceNetworkAclAssociation(ctx context.Context, params *ec2.ReplaceNetworkAclAssociationInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceNetworkAclAssociationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReplaceNetworkAclAssociation")
	}

	var r0 *ec2.ReplaceNetworkAclAssociationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceNetworkAclAssociationInput, ...func(*ec2.Options)) (*ec2.ReplaceNetworkAclAssociationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceNetworkAclAssociationInput, ...func(*ec2.Options)) *ec2.ReplaceNetworkAclAssociationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceNetworkAclAssociationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceNetworkAclAssociationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReplaceNetworkAclAssociation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceNetworkAclAssociation'
type EC2_ReplaceNetworkAclAssociation_Call struct {
	*mock.Call
}

// ReplaceNetworkAclAssociation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReplaceNetworkAclAssociationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReplaceNetworkAclAssociation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReplaceNetworkAclAssociation_Call {
	return &EC2_ReplaceNetworkAclAssociation_Call{Call: _e.mock.On("ReplaceNetworkAclAssociation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReplaceNetworkAclAssociation_Call) Run(run func(ctx context.Context, params *ec2.ReplaceNetworkAclAssociationInput, optFns ...func(*ec2.Options))) *EC2_ReplaceNetworkAclAssociation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReplaceNetworkAclAssociationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReplaceNetworkAclAssociation_Call) Return(_a0 *ec2.ReplaceNetworkAclAssociationOutput, _a1 error) *EC2_ReplaceNetworkAclAssociation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReplaceNetworkAclAssociation_Call) RunAndReturn(run func(context.Context, *ec2.ReplaceNetworkAclAssociationInput, ...func(*ec2.Options)) (*ec2.ReplaceNetworkAclAssociationOutput, error)) *EC2_ReplaceNetworkAclAssociation_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceNetworkAclEntry provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReplaceNetworkAclEntry(ctx context.Context, params *ec2.ReplaceNetworkAclEntryInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceNetworkAclEntryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReplaceNetworkAclEntry")
	}

	var r0 *ec2.ReplaceNetworkAclEntryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceNetworkAclEntryInput, ...func(*ec2.Options)) (*ec2.ReplaceNetworkAclEntryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceNetworkAclEntryInput, ...func(*ec2.Options)) *ec2.ReplaceNetworkAclEntryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceNetworkAclEntryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceNetworkAclEntryInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReplaceNetworkAclEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceNetworkAclEntry'
type EC2_ReplaceNetworkAclEntry_Call struct {
	*mock.Call
}

// ReplaceNetworkAclEntry is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReplaceNetworkAclEntryInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReplaceNetworkAclEntry(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReplaceNetworkAclEntry_Call {
	return &EC2_ReplaceNetworkAclEntry_Call{Call: _e.mock.On("ReplaceNetworkAclEntry",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReplaceNetworkAclEntry_Call) Run(run func(ctx context.Context, params *ec2.ReplaceNetworkAclEntryInput, optFns ...func(*ec2.Options))) *EC2_ReplaceNetworkAclEntry_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReplaceNetworkAclEntryInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReplaceNetworkAclEntry_Call) Return(_a0 *ec2.ReplaceNetworkAclEntryOutput, _a1 error) *EC2_ReplaceNetworkAclEntry_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReplaceNetworkAclEntry_Call) RunAndReturn(run func(context.Context, *ec2.ReplaceNetworkAclEntryInput, ...func(*ec2.Options)) (*ec2.ReplaceNetworkAclEntryOutput, error)) *EC2_ReplaceNetworkAclEntry_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReplaceRoute(ctx context.Context, params *ec2.ReplaceRouteInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReplaceRoute")
	}

	var r0 *ec2.ReplaceRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceRouteInput, ...func(*ec2.Options)) (*ec2.ReplaceRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceRouteInput, ...func(*ec2.Options)) *ec2.ReplaceRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReplaceRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceRoute'
type EC2_ReplaceRoute_Call struct {
	*mock.Call
}

// ReplaceRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReplaceRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReplaceRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReplaceRoute_Call {
	return &EC2_ReplaceRoute_Call{Call: _e.mock.On("ReplaceRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReplaceRoute_Call) Run(run func(ctx context.Context, params *ec2.ReplaceRouteInput, optFns ...func(*ec2.Options))) *EC2_ReplaceRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReplaceRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReplaceRoute_Call) Return(_a0 *ec2.ReplaceRouteOutput, _a1 error) *EC2_ReplaceRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReplaceRoute_Call) RunAndReturn(run func(context.Context, *ec2.ReplaceRouteInput, ...func(*ec2.Options)) (*ec2.ReplaceRouteOutput, error)) *EC2_ReplaceRoute_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceRouteTableAssociation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReplaceRouteTableAssociation(ctx context.Context, params *ec2.ReplaceRouteTableAssociationInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceRouteTableAssociationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReplaceRouteTableAssociation")
	}

	var r0 *ec2.ReplaceRouteTableAssociationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceRouteTableAssociationInput, ...func(*ec2.Options)) (*ec2.ReplaceRouteTableAssociationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceRouteTableAssociationInput, ...func(*ec2.Options)) *ec2.ReplaceRouteTableAssociationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceRouteTableAssociationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceRouteTableAssociationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReplaceRouteTableAssociation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceRouteTableAssociation'
type EC2_ReplaceRouteTableAssociation_Call struct {
	*mock.Call
}

// ReplaceRouteTableAssociation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReplaceRouteTableAssociationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReplaceRouteTableAssociation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReplaceRouteTableAssociation_Call {
	return &EC2_ReplaceRouteTableAssociation_Call{Call: _e.mock.On("ReplaceRouteTableAssociation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReplaceRouteTableAssociation_Call) Run(run func(ctx context.Context, params *ec2.ReplaceRouteTableAssociationInput, optFns ...func(*ec2.Options))) *EC2_ReplaceRouteTableAssociation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReplaceRouteTableAssociationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReplaceRouteTableAssociation_Call) Return(_a0 *ec2.ReplaceRouteTableAssociationOutput, _a1 error) *EC2_ReplaceRouteTableAssociation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReplaceRouteTableAssociation_Call) RunAndReturn(run func(context.Context, *ec2.ReplaceRouteTableAssociationInput, ...func(*ec2.Options)) (*ec2.ReplaceRouteTableAssociationOutput, error)) *EC2_ReplaceRouteTableAssociation_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceTransitGatewayRoute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReplaceTransitGatewayRoute(ctx context.Context, params *ec2.ReplaceTransitGatewayRouteInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceTransitGatewayRouteOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReplaceTransitGatewayRoute")
	}

	var r0 *ec2.ReplaceTransitGatewayRouteOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceTransitGatewayRouteInput, ...func(*ec2.Options)) (*ec2.ReplaceTransitGatewayRouteOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceTransitGatewayRouteInput, ...func(*ec2.Options)) *ec2.ReplaceTransitGatewayRouteOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceTransitGatewayRouteOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceTransitGatewayRouteInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReplaceTransitGatewayRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceTransitGatewayRoute'
type EC2_ReplaceTransitGatewayRoute_Call struct {
	*mock.Call
}

// ReplaceTransitGatewayRoute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReplaceTransitGatewayRouteInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReplaceTransitGatewayRoute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReplaceTransitGatewayRoute_Call {
	return &EC2_ReplaceTransitGatewayRoute_Call{Call: _e.mock.On("ReplaceTransitGatewayRoute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReplaceTransitGatewayRoute_Call) Run(run func(ctx context.Context, params *ec2.ReplaceTransitGatewayRouteInput, optFns ...func(*ec2.Options))) *EC2_ReplaceTransitGatewayRoute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReplaceTransitGatewayRouteInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReplaceTransitGatewayRoute_Call) Return(_a0 *ec2.ReplaceTransitGatewayRouteOutput, _a1 error) *EC2_ReplaceTransitGatewayRoute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReplaceTransitGatewayRoute_Call) RunAndReturn(run func(context.Context, *ec2.ReplaceTransitGatewayRouteInput, ...func(*ec2.Options)) (*ec2.ReplaceTransitGatewayRouteOutput, error)) *EC2_ReplaceTransitGatewayRoute_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceVpnTunnel provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReplaceVpnTunnel(ctx context.Context, params *ec2.ReplaceVpnTunnelInput, optFns ...func(*ec2.Options)) (*ec2.ReplaceVpnTunnelOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReplaceVpnTunnel")
	}

	var r0 *ec2.ReplaceVpnTunnelOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceVpnTunnelInput, ...func(*ec2.Options)) (*ec2.ReplaceVpnTunnelOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReplaceVpnTunnelInput, ...func(*ec2.Options)) *ec2.ReplaceVpnTunnelOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReplaceVpnTunnelOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReplaceVpnTunnelInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReplaceVpnTunnel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplaceVpnTunnel'
type EC2_ReplaceVpnTunnel_Call struct {
	*mock.Call
}

// ReplaceVpnTunnel is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReplaceVpnTunnelInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReplaceVpnTunnel(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReplaceVpnTunnel_Call {
	return &EC2_ReplaceVpnTunnel_Call{Call: _e.mock.On("ReplaceVpnTunnel",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReplaceVpnTunnel_Call) Run(run func(ctx context.Context, params *ec2.ReplaceVpnTunnelInput, optFns ...func(*ec2.Options))) *EC2_ReplaceVpnTunnel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReplaceVpnTunnelInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReplaceVpnTunnel_Call) Return(_a0 *ec2.ReplaceVpnTunnelOutput, _a1 error) *EC2_ReplaceVpnTunnel_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReplaceVpnTunnel_Call) RunAndReturn(run func(context.Context, *ec2.ReplaceVpnTunnelInput, ...func(*ec2.Options)) (*ec2.ReplaceVpnTunnelOutput, error)) *EC2_ReplaceVpnTunnel_Call {
	_c.Call.Return(run)
	return _c
}

// ReportInstanceStatus provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ReportInstanceStatus(ctx context.Context, params *ec2.ReportInstanceStatusInput, optFns ...func(*ec2.Options)) (*ec2.ReportInstanceStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReportInstanceStatus")
	}

	var r0 *ec2.ReportInstanceStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReportInstanceStatusInput, ...func(*ec2.Options)) (*ec2.ReportInstanceStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ReportInstanceStatusInput, ...func(*ec2.Options)) *ec2.ReportInstanceStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ReportInstanceStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ReportInstanceStatusInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ReportInstanceStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportInstanceStatus'
type EC2_ReportInstanceStatus_Call struct {
	*mock.Call
}

// ReportInstanceStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ReportInstanceStatusInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ReportInstanceStatus(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ReportInstanceStatus_Call {
	return &EC2_ReportInstanceStatus_Call{Call: _e.mock.On("ReportInstanceStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ReportInstanceStatus_Call) Run(run func(ctx context.Context, params *ec2.ReportInstanceStatusInput, optFns ...func(*ec2.Options))) *EC2_ReportInstanceStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ReportInstanceStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ReportInstanceStatus_Call) Return(_a0 *ec2.ReportInstanceStatusOutput, _a1 error) *EC2_ReportInstanceStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ReportInstanceStatus_Call) RunAndReturn(run func(context.Context, *ec2.ReportInstanceStatusInput, ...func(*ec2.Options)) (*ec2.ReportInstanceStatusOutput, error)) *EC2_ReportInstanceStatus_Call {
	_c.Call.Return(run)
	return _c
}

// RequestSpotFleet provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RequestSpotFleet(ctx context.Context, params *ec2.RequestSpotFleetInput, optFns ...func(*ec2.Options)) (*ec2.RequestSpotFleetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RequestSpotFleet")
	}

	var r0 *ec2.RequestSpotFleetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RequestSpotFleetInput, ...func(*ec2.Options)) (*ec2.RequestSpotFleetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RequestSpotFleetInput, ...func(*ec2.Options)) *ec2.RequestSpotFleetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RequestSpotFleetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RequestSpotFleetInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RequestSpotFleet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestSpotFleet'
type EC2_RequestSpotFleet_Call struct {
	*mock.Call
}

// RequestSpotFleet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RequestSpotFleetInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RequestSpotFleet(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RequestSpotFleet_Call {
	return &EC2_RequestSpotFleet_Call{Call: _e.mock.On("RequestSpotFleet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RequestSpotFleet_Call) Run(run func(ctx context.Context, params *ec2.RequestSpotFleetInput, optFns ...func(*ec2.Options))) *EC2_RequestSpotFleet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RequestSpotFleetInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RequestSpotFleet_Call) Return(_a0 *ec2.RequestSpotFleetOutput, _a1 error) *EC2_RequestSpotFleet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RequestSpotFleet_Call) RunAndReturn(run func(context.Context, *ec2.RequestSpotFleetInput, ...func(*ec2.Options)) (*ec2.RequestSpotFleetOutput, error)) *EC2_RequestSpotFleet_Call {
	_c.Call.Return(run)
	return _c
}

// RequestSpotInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RequestSpotInstances(ctx context.Context, params *ec2.RequestSpotInstancesInput, optFns ...func(*ec2.Options)) (*ec2.RequestSpotInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RequestSpotInstances")
	}

	var r0 *ec2.RequestSpotInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RequestSpotInstancesInput, ...func(*ec2.Options)) (*ec2.RequestSpotInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RequestSpotInstancesInput, ...func(*ec2.Options)) *ec2.RequestSpotInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RequestSpotInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RequestSpotInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RequestSpotInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestSpotInstances'
type EC2_RequestSpotInstances_Call struct {
	*mock.Call
}

// RequestSpotInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RequestSpotInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RequestSpotInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RequestSpotInstances_Call {
	return &EC2_RequestSpotInstances_Call{Call: _e.mock.On("RequestSpotInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RequestSpotInstances_Call) Run(run func(ctx context.Context, params *ec2.RequestSpotInstancesInput, optFns ...func(*ec2.Options))) *EC2_RequestSpotInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RequestSpotInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RequestSpotInstances_Call) Return(_a0 *ec2.RequestSpotInstancesOutput, _a1 error) *EC2_RequestSpotInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RequestSpotInstances_Call) RunAndReturn(run func(context.Context, *ec2.RequestSpotInstancesInput, ...func(*ec2.Options)) (*ec2.RequestSpotInstancesOutput, error)) *EC2_RequestSpotInstances_Call {
	_c.Call.Return(run)
	return _c
}

// ResetAddressAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ResetAddressAttribute(ctx context.Context, params *ec2.ResetAddressAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ResetAddressAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ResetAddressAttribute")
	}

	var r0 *ec2.ResetAddressAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetAddressAttributeInput, ...func(*ec2.Options)) (*ec2.ResetAddressAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetAddressAttributeInput, ...func(*ec2.Options)) *ec2.ResetAddressAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetAddressAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetAddressAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ResetAddressAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetAddressAttribute'
type EC2_ResetAddressAttribute_Call struct {
	*mock.Call
}

// ResetAddressAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ResetAddressAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ResetAddressAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ResetAddressAttribute_Call {
	return &EC2_ResetAddressAttribute_Call{Call: _e.mock.On("ResetAddressAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ResetAddressAttribute_Call) Run(run func(ctx context.Context, params *ec2.ResetAddressAttributeInput, optFns ...func(*ec2.Options))) *EC2_ResetAddressAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ResetAddressAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ResetAddressAttribute_Call) Return(_a0 *ec2.ResetAddressAttributeOutput, _a1 error) *EC2_ResetAddressAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ResetAddressAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ResetAddressAttributeInput, ...func(*ec2.Options)) (*ec2.ResetAddressAttributeOutput, error)) *EC2_ResetAddressAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ResetEbsDefaultKmsKeyId provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ResetEbsDefaultKmsKeyId(ctx context.Context, params *ec2.ResetEbsDefaultKmsKeyIdInput, optFns ...func(*ec2.Options)) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ResetEbsDefaultKmsKeyId")
	}

	var r0 *ec2.ResetEbsDefaultKmsKeyIdOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) *ec2.ResetEbsDefaultKmsKeyIdOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetEbsDefaultKmsKeyIdOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ResetEbsDefaultKmsKeyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetEbsDefaultKmsKeyId'
type EC2_ResetEbsDefaultKmsKeyId_Call struct {
	*mock.Call
}

// ResetEbsDefaultKmsKeyId is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ResetEbsDefaultKmsKeyIdInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ResetEbsDefaultKmsKeyId(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ResetEbsDefaultKmsKeyId_Call {
	return &EC2_ResetEbsDefaultKmsKeyId_Call{Call: _e.mock.On("ResetEbsDefaultKmsKeyId",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ResetEbsDefaultKmsKeyId_Call) Run(run func(ctx context.Context, params *ec2.ResetEbsDefaultKmsKeyIdInput, optFns ...func(*ec2.Options))) *EC2_ResetEbsDefaultKmsKeyId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ResetEbsDefaultKmsKeyIdInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ResetEbsDefaultKmsKeyId_Call) Return(_a0 *ec2.ResetEbsDefaultKmsKeyIdOutput, _a1 error) *EC2_ResetEbsDefaultKmsKeyId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ResetEbsDefaultKmsKeyId_Call) RunAndReturn(run func(context.Context, *ec2.ResetEbsDefaultKmsKeyIdInput, ...func(*ec2.Options)) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error)) *EC2_ResetEbsDefaultKmsKeyId_Call {
	_c.Call.Return(run)
	return _c
}

// ResetFpgaImageAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ResetFpgaImageAttribute(ctx context.Context, params *ec2.ResetFpgaImageAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ResetFpgaImageAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ResetFpgaImageAttribute")
	}

	var r0 *ec2.ResetFpgaImageAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetFpgaImageAttributeInput, ...func(*ec2.Options)) (*ec2.ResetFpgaImageAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetFpgaImageAttributeInput, ...func(*ec2.Options)) *ec2.ResetFpgaImageAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetFpgaImageAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetFpgaImageAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ResetFpgaImageAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetFpgaImageAttribute'
type EC2_ResetFpgaImageAttribute_Call struct {
	*mock.Call
}

// ResetFpgaImageAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ResetFpgaImageAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ResetFpgaImageAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ResetFpgaImageAttribute_Call {
	return &EC2_ResetFpgaImageAttribute_Call{Call: _e.mock.On("ResetFpgaImageAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ResetFpgaImageAttribute_Call) Run(run func(ctx context.Context, params *ec2.ResetFpgaImageAttributeInput, optFns ...func(*ec2.Options))) *EC2_ResetFpgaImageAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ResetFpgaImageAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ResetFpgaImageAttribute_Call) Return(_a0 *ec2.ResetFpgaImageAttributeOutput, _a1 error) *EC2_ResetFpgaImageAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ResetFpgaImageAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ResetFpgaImageAttributeInput, ...func(*ec2.Options)) (*ec2.ResetFpgaImageAttributeOutput, error)) *EC2_ResetFpgaImageAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ResetImageAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ResetImageAttribute(ctx context.Context, params *ec2.ResetImageAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ResetImageAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ResetImageAttribute")
	}

	var r0 *ec2.ResetImageAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetImageAttributeInput, ...func(*ec2.Options)) (*ec2.ResetImageAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetImageAttributeInput, ...func(*ec2.Options)) *ec2.ResetImageAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetImageAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetImageAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ResetImageAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetImageAttribute'
type EC2_ResetImageAttribute_Call struct {
	*mock.Call
}

// ResetImageAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ResetImageAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ResetImageAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ResetImageAttribute_Call {
	return &EC2_ResetImageAttribute_Call{Call: _e.mock.On("ResetImageAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ResetImageAttribute_Call) Run(run func(ctx context.Context, params *ec2.ResetImageAttributeInput, optFns ...func(*ec2.Options))) *EC2_ResetImageAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ResetImageAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ResetImageAttribute_Call) Return(_a0 *ec2.ResetImageAttributeOutput, _a1 error) *EC2_ResetImageAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ResetImageAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ResetImageAttributeInput, ...func(*ec2.Options)) (*ec2.ResetImageAttributeOutput, error)) *EC2_ResetImageAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ResetInstanceAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ResetInstanceAttribute(ctx context.Context, params *ec2.ResetInstanceAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ResetInstanceAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ResetInstanceAttribute")
	}

	var r0 *ec2.ResetInstanceAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetInstanceAttributeInput, ...func(*ec2.Options)) (*ec2.ResetInstanceAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetInstanceAttributeInput, ...func(*ec2.Options)) *ec2.ResetInstanceAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetInstanceAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetInstanceAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ResetInstanceAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetInstanceAttribute'
type EC2_ResetInstanceAttribute_Call struct {
	*mock.Call
}

// ResetInstanceAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ResetInstanceAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ResetInstanceAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ResetInstanceAttribute_Call {
	return &EC2_ResetInstanceAttribute_Call{Call: _e.mock.On("ResetInstanceAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ResetInstanceAttribute_Call) Run(run func(ctx context.Context, params *ec2.ResetInstanceAttributeInput, optFns ...func(*ec2.Options))) *EC2_ResetInstanceAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ResetInstanceAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ResetInstanceAttribute_Call) Return(_a0 *ec2.ResetInstanceAttributeOutput, _a1 error) *EC2_ResetInstanceAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ResetInstanceAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ResetInstanceAttributeInput, ...func(*ec2.Options)) (*ec2.ResetInstanceAttributeOutput, error)) *EC2_ResetInstanceAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ResetNetworkInterfaceAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ResetNetworkInterfaceAttribute(ctx context.Context, params *ec2.ResetNetworkInterfaceAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ResetNetworkInterfaceAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ResetNetworkInterfaceAttribute")
	}

	var r0 *ec2.ResetNetworkInterfaceAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetNetworkInterfaceAttributeInput, ...func(*ec2.Options)) (*ec2.ResetNetworkInterfaceAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetNetworkInterfaceAttributeInput, ...func(*ec2.Options)) *ec2.ResetNetworkInterfaceAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetNetworkInterfaceAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetNetworkInterfaceAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ResetNetworkInterfaceAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetNetworkInterfaceAttribute'
type EC2_ResetNetworkInterfaceAttribute_Call struct {
	*mock.Call
}

// ResetNetworkInterfaceAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ResetNetworkInterfaceAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ResetNetworkInterfaceAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ResetNetworkInterfaceAttribute_Call {
	return &EC2_ResetNetworkInterfaceAttribute_Call{Call: _e.mock.On("ResetNetworkInterfaceAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ResetNetworkInterfaceAttribute_Call) Run(run func(ctx context.Context, params *ec2.ResetNetworkInterfaceAttributeInput, optFns ...func(*ec2.Options))) *EC2_ResetNetworkInterfaceAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ResetNetworkInterfaceAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ResetNetworkInterfaceAttribute_Call) Return(_a0 *ec2.ResetNetworkInterfaceAttributeOutput, _a1 error) *EC2_ResetNetworkInterfaceAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ResetNetworkInterfaceAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ResetNetworkInterfaceAttributeInput, ...func(*ec2.Options)) (*ec2.ResetNetworkInterfaceAttributeOutput, error)) *EC2_ResetNetworkInterfaceAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// ResetSnapshotAttribute provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) ResetSnapshotAttribute(ctx context.Context, params *ec2.ResetSnapshotAttributeInput, optFns ...func(*ec2.Options)) (*ec2.ResetSnapshotAttributeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ResetSnapshotAttribute")
	}

	var r0 *ec2.ResetSnapshotAttributeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetSnapshotAttributeInput, ...func(*ec2.Options)) (*ec2.ResetSnapshotAttributeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.ResetSnapshotAttributeInput, ...func(*ec2.Options)) *ec2.ResetSnapshotAttributeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.ResetSnapshotAttributeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.ResetSnapshotAttributeInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_ResetSnapshotAttribute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetSnapshotAttribute'
type EC2_ResetSnapshotAttribute_Call struct {
	*mock.Call
}

// ResetSnapshotAttribute is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.ResetSnapshotAttributeInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) ResetSnapshotAttribute(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_ResetSnapshotAttribute_Call {
	return &EC2_ResetSnapshotAttribute_Call{Call: _e.mock.On("ResetSnapshotAttribute",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_ResetSnapshotAttribute_Call) Run(run func(ctx context.Context, params *ec2.ResetSnapshotAttributeInput, optFns ...func(*ec2.Options))) *EC2_ResetSnapshotAttribute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.ResetSnapshotAttributeInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_ResetSnapshotAttribute_Call) Return(_a0 *ec2.ResetSnapshotAttributeOutput, _a1 error) *EC2_ResetSnapshotAttribute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_ResetSnapshotAttribute_Call) RunAndReturn(run func(context.Context, *ec2.ResetSnapshotAttributeInput, ...func(*ec2.Options)) (*ec2.ResetSnapshotAttributeOutput, error)) *EC2_ResetSnapshotAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreAddressToClassic provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RestoreAddressToClassic(ctx context.Context, params *ec2.RestoreAddressToClassicInput, optFns ...func(*ec2.Options)) (*ec2.RestoreAddressToClassicOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RestoreAddressToClassic")
	}

	var r0 *ec2.RestoreAddressToClassicOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreAddressToClassicInput, ...func(*ec2.Options)) (*ec2.RestoreAddressToClassicOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreAddressToClassicInput, ...func(*ec2.Options)) *ec2.RestoreAddressToClassicOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreAddressToClassicOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreAddressToClassicInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RestoreAddressToClassic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreAddressToClassic'
type EC2_RestoreAddressToClassic_Call struct {
	*mock.Call
}

// RestoreAddressToClassic is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RestoreAddressToClassicInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RestoreAddressToClassic(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RestoreAddressToClassic_Call {
	return &EC2_RestoreAddressToClassic_Call{Call: _e.mock.On("RestoreAddressToClassic",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RestoreAddressToClassic_Call) Run(run func(ctx context.Context, params *ec2.RestoreAddressToClassicInput, optFns ...func(*ec2.Options))) *EC2_RestoreAddressToClassic_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RestoreAddressToClassicInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RestoreAddressToClassic_Call) Return(_a0 *ec2.RestoreAddressToClassicOutput, _a1 error) *EC2_RestoreAddressToClassic_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RestoreAddressToClassic_Call) RunAndReturn(run func(context.Context, *ec2.RestoreAddressToClassicInput, ...func(*ec2.Options)) (*ec2.RestoreAddressToClassicOutput, error)) *EC2_RestoreAddressToClassic_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreImageFromRecycleBin provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RestoreImageFromRecycleBin(ctx context.Context, params *ec2.RestoreImageFromRecycleBinInput, optFns ...func(*ec2.Options)) (*ec2.RestoreImageFromRecycleBinOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RestoreImageFromRecycleBin")
	}

	var r0 *ec2.RestoreImageFromRecycleBinOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreImageFromRecycleBinInput, ...func(*ec2.Options)) (*ec2.RestoreImageFromRecycleBinOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreImageFromRecycleBinInput, ...func(*ec2.Options)) *ec2.RestoreImageFromRecycleBinOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreImageFromRecycleBinOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreImageFromRecycleBinInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RestoreImageFromRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreImageFromRecycleBin'
type EC2_RestoreImageFromRecycleBin_Call struct {
	*mock.Call
}

// RestoreImageFromRecycleBin is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RestoreImageFromRecycleBinInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RestoreImageFromRecycleBin(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RestoreImageFromRecycleBin_Call {
	return &EC2_RestoreImageFromRecycleBin_Call{Call: _e.mock.On("RestoreImageFromRecycleBin",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RestoreImageFromRecycleBin_Call) Run(run func(ctx context.Context, params *ec2.RestoreImageFromRecycleBinInput, optFns ...func(*ec2.Options))) *EC2_RestoreImageFromRecycleBin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RestoreImageFromRecycleBinInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RestoreImageFromRecycleBin_Call) Return(_a0 *ec2.RestoreImageFromRecycleBinOutput, _a1 error) *EC2_RestoreImageFromRecycleBin_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RestoreImageFromRecycleBin_Call) RunAndReturn(run func(context.Context, *ec2.RestoreImageFromRecycleBinInput, ...func(*ec2.Options)) (*ec2.RestoreImageFromRecycleBinOutput, error)) *EC2_RestoreImageFromRecycleBin_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreManagedPrefixListVersion provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RestoreManagedPrefixListVersion(ctx context.Context, params *ec2.RestoreManagedPrefixListVersionInput, optFns ...func(*ec2.Options)) (*ec2.RestoreManagedPrefixListVersionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RestoreManagedPrefixListVersion")
	}

	var r0 *ec2.RestoreManagedPrefixListVersionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreManagedPrefixListVersionInput, ...func(*ec2.Options)) (*ec2.RestoreManagedPrefixListVersionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreManagedPrefixListVersionInput, ...func(*ec2.Options)) *ec2.RestoreManagedPrefixListVersionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreManagedPrefixListVersionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreManagedPrefixListVersionInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RestoreManagedPrefixListVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreManagedPrefixListVersion'
type EC2_RestoreManagedPrefixListVersion_Call struct {
	*mock.Call
}

// RestoreManagedPrefixListVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RestoreManagedPrefixListVersionInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RestoreManagedPrefixListVersion(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RestoreManagedPrefixListVersion_Call {
	return &EC2_RestoreManagedPrefixListVersion_Call{Call: _e.mock.On("RestoreManagedPrefixListVersion",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RestoreManagedPrefixListVersion_Call) Run(run func(ctx context.Context, params *ec2.RestoreManagedPrefixListVersionInput, optFns ...func(*ec2.Options))) *EC2_RestoreManagedPrefixListVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RestoreManagedPrefixListVersionInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RestoreManagedPrefixListVersion_Call) Return(_a0 *ec2.RestoreManagedPrefixListVersionOutput, _a1 error) *EC2_RestoreManagedPrefixListVersion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RestoreManagedPrefixListVersion_Call) RunAndReturn(run func(context.Context, *ec2.RestoreManagedPrefixListVersionInput, ...func(*ec2.Options)) (*ec2.RestoreManagedPrefixListVersionOutput, error)) *EC2_RestoreManagedPrefixListVersion_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreSnapshotFromRecycleBin provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RestoreSnapshotFromRecycleBin(ctx context.Context, params *ec2.RestoreSnapshotFromRecycleBinInput, optFns ...func(*ec2.Options)) (*ec2.RestoreSnapshotFromRecycleBinOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RestoreSnapshotFromRecycleBin")
	}

	var r0 *ec2.RestoreSnapshotFromRecycleBinOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreSnapshotFromRecycleBinInput, ...func(*ec2.Options)) (*ec2.RestoreSnapshotFromRecycleBinOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreSnapshotFromRecycleBinInput, ...func(*ec2.Options)) *ec2.RestoreSnapshotFromRecycleBinOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreSnapshotFromRecycleBinOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreSnapshotFromRecycleBinInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RestoreSnapshotFromRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreSnapshotFromRecycleBin'
type EC2_RestoreSnapshotFromRecycleBin_Call struct {
	*mock.Call
}

// RestoreSnapshotFromRecycleBin is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RestoreSnapshotFromRecycleBinInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RestoreSnapshotFromRecycleBin(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RestoreSnapshotFromRecycleBin_Call {
	return &EC2_RestoreSnapshotFromRecycleBin_Call{Call: _e.mock.On("RestoreSnapshotFromRecycleBin",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RestoreSnapshotFromRecycleBin_Call) Run(run func(ctx context.Context, params *ec2.RestoreSnapshotFromRecycleBinInput, optFns ...func(*ec2.Options))) *EC2_RestoreSnapshotFromRecycleBin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RestoreSnapshotFromRecycleBinInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RestoreSnapshotFromRecycleBin_Call) Return(_a0 *ec2.RestoreSnapshotFromRecycleBinOutput, _a1 error) *EC2_RestoreSnapshotFromRecycleBin_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RestoreSnapshotFromRecycleBin_Call) RunAndReturn(run func(context.Context, *ec2.RestoreSnapshotFromRecycleBinInput, ...func(*ec2.Options)) (*ec2.RestoreSnapshotFromRecycleBinOutput, error)) *EC2_RestoreSnapshotFromRecycleBin_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreSnapshotTier provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RestoreSnapshotTier(ctx context.Context, params *ec2.RestoreSnapshotTierInput, optFns ...func(*ec2.Options)) (*ec2.RestoreSnapshotTierOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RestoreSnapshotTier")
	}

	var r0 *ec2.RestoreSnapshotTierOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreSnapshotTierInput, ...func(*ec2.Options)) (*ec2.RestoreSnapshotTierOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreSnapshotTierInput, ...func(*ec2.Options)) *ec2.RestoreSnapshotTierOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreSnapshotTierOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreSnapshotTierInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RestoreSnapshotTier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreSnapshotTier'
type EC2_RestoreSnapshotTier_Call struct {
	*mock.Call
}

// RestoreSnapshotTier is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RestoreSnapshotTierInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RestoreSnapshotTier(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RestoreSnapshotTier_Call {
	return &EC2_RestoreSnapshotTier_Call{Call: _e.mock.On("RestoreSnapshotTier",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RestoreSnapshotTier_Call) Run(run func(ctx context.Context, params *ec2.RestoreSnapshotTierInput, optFns ...func(*ec2.Options))) *EC2_RestoreSnapshotTier_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RestoreSnapshotTierInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RestoreSnapshotTier_Call) Return(_a0 *ec2.RestoreSnapshotTierOutput, _a1 error) *EC2_RestoreSnapshotTier_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RestoreSnapshotTier_Call) RunAndReturn(run func(context.Context, *ec2.RestoreSnapshotTierInput, ...func(*ec2.Options)) (*ec2.RestoreSnapshotTierOutput, error)) *EC2_RestoreSnapshotTier_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreVolumeFromRecycleBin provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RestoreVolumeFromRecycleBin(ctx context.Context, params *ec2.RestoreVolumeFromRecycleBinInput, optFns ...func(*ec2.Options)) (*ec2.RestoreVolumeFromRecycleBinOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RestoreVolumeFromRecycleBin")
	}

	var r0 *ec2.RestoreVolumeFromRecycleBinOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreVolumeFromRecycleBinInput, ...func(*ec2.Options)) (*ec2.RestoreVolumeFromRecycleBinOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RestoreVolumeFromRecycleBinInput, ...func(*ec2.Options)) *ec2.RestoreVolumeFromRecycleBinOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RestoreVolumeFromRecycleBinOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RestoreVolumeFromRecycleBinInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RestoreVolumeFromRecycleBin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreVolumeFromRecycleBin'
type EC2_RestoreVolumeFromRecycleBin_Call struct {
	*mock.Call
}

// RestoreVolumeFromRecycleBin is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RestoreVolumeFromRecycleBinInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RestoreVolumeFromRecycleBin(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RestoreVolumeFromRecycleBin_Call {
	return &EC2_RestoreVolumeFromRecycleBin_Call{Call: _e.mock.On("RestoreVolumeFromRecycleBin",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RestoreVolumeFromRecycleBin_Call) Run(run func(ctx context.Context, params *ec2.RestoreVolumeFromRecycleBinInput, optFns ...func(*ec2.Options))) *EC2_RestoreVolumeFromRecycleBin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RestoreVolumeFromRecycleBinInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RestoreVolumeFromRecycleBin_Call) Return(_a0 *ec2.RestoreVolumeFromRecycleBinOutput, _a1 error) *EC2_RestoreVolumeFromRecycleBin_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RestoreVolumeFromRecycleBin_Call) RunAndReturn(run func(context.Context, *ec2.RestoreVolumeFromRecycleBinInput, ...func(*ec2.Options)) (*ec2.RestoreVolumeFromRecycleBinOutput, error)) *EC2_RestoreVolumeFromRecycleBin_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeClientVpnIngress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RevokeClientVpnIngress(ctx context.Context, params *ec2.RevokeClientVpnIngressInput, optFns ...func(*ec2.Options)) (*ec2.RevokeClientVpnIngressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RevokeClientVpnIngress")
	}

	var r0 *ec2.RevokeClientVpnIngressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeClientVpnIngressInput, ...func(*ec2.Options)) (*ec2.RevokeClientVpnIngressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeClientVpnIngressInput, ...func(*ec2.Options)) *ec2.RevokeClientVpnIngressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeClientVpnIngressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RevokeClientVpnIngressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RevokeClientVpnIngress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeClientVpnIngress'
type EC2_RevokeClientVpnIngress_Call struct {
	*mock.Call
}

// RevokeClientVpnIngress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RevokeClientVpnIngressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RevokeClientVpnIngress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RevokeClientVpnIngress_Call {
	return &EC2_RevokeClientVpnIngress_Call{Call: _e.mock.On("RevokeClientVpnIngress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RevokeClientVpnIngress_Call) Run(run func(ctx context.Context, params *ec2.RevokeClientVpnIngressInput, optFns ...func(*ec2.Options))) *EC2_RevokeClientVpnIngress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RevokeClientVpnIngressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RevokeClientVpnIngress_Call) Return(_a0 *ec2.RevokeClientVpnIngressOutput, _a1 error) *EC2_RevokeClientVpnIngress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RevokeClientVpnIngress_Call) RunAndReturn(run func(context.Context, *ec2.RevokeClientVpnIngressInput, ...func(*ec2.Options)) (*ec2.RevokeClientVpnIngressOutput, error)) *EC2_RevokeClientVpnIngress_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeSecurityGroupEgress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RevokeSecurityGroupEgress(ctx context.Context, params *ec2.RevokeSecurityGroupEgressInput, optFns ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupEgressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RevokeSecurityGroupEgress")
	}

	var r0 *ec2.RevokeSecurityGroupEgressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeSecurityGroupEgressInput, ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupEgressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeSecurityGroupEgressInput, ...func(*ec2.Options)) *ec2.RevokeSecurityGroupEgressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeSecurityGroupEgressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RevokeSecurityGroupEgressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RevokeSecurityGroupEgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeSecurityGroupEgress'
type EC2_RevokeSecurityGroupEgress_Call struct {
	*mock.Call
}

// RevokeSecurityGroupEgress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RevokeSecurityGroupEgressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RevokeSecurityGroupEgress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RevokeSecurityGroupEgress_Call {
	return &EC2_RevokeSecurityGroupEgress_Call{Call: _e.mock.On("RevokeSecurityGroupEgress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RevokeSecurityGroupEgress_Call) Run(run func(ctx context.Context, params *ec2.RevokeSecurityGroupEgressInput, optFns ...func(*ec2.Options))) *EC2_RevokeSecurityGroupEgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RevokeSecurityGroupEgressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RevokeSecurityGroupEgress_Call) Return(_a0 *ec2.RevokeSecurityGroupEgressOutput, _a1 error) *EC2_RevokeSecurityGroupEgress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RevokeSecurityGroupEgress_Call) RunAndReturn(run func(context.Context, *ec2.RevokeSecurityGroupEgressInput, ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupEgressOutput, error)) *EC2_RevokeSecurityGroupEgress_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeSecurityGroupIngress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RevokeSecurityGroupIngress(ctx context.Context, params *ec2.RevokeSecurityGroupIngressInput, optFns ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupIngressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RevokeSecurityGroupIngress")
	}

	var r0 *ec2.RevokeSecurityGroupIngressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeSecurityGroupIngressInput, ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupIngressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RevokeSecurityGroupIngressInput, ...func(*ec2.Options)) *ec2.RevokeSecurityGroupIngressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RevokeSecurityGroupIngressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RevokeSecurityGroupIngressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RevokeSecurityGroupIngress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeSecurityGroupIngress'
type EC2_RevokeSecurityGroupIngress_Call struct {
	*mock.Call
}

// RevokeSecurityGroupIngress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RevokeSecurityGroupIngressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RevokeSecurityGroupIngress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RevokeSecurityGroupIngress_Call {
	return &EC2_RevokeSecurityGroupIngress_Call{Call: _e.mock.On("RevokeSecurityGroupIngress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RevokeSecurityGroupIngress_Call) Run(run func(ctx context.Context, params *ec2.RevokeSecurityGroupIngressInput, optFns ...func(*ec2.Options))) *EC2_RevokeSecurityGroupIngress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RevokeSecurityGroupIngressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RevokeSecurityGroupIngress_Call) Return(_a0 *ec2.RevokeSecurityGroupIngressOutput, _a1 error) *EC2_RevokeSecurityGroupIngress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RevokeSecurityGroupIngress_Call) RunAndReturn(run func(context.Context, *ec2.RevokeSecurityGroupIngressInput, ...func(*ec2.Options)) (*ec2.RevokeSecurityGroupIngressOutput, error)) *EC2_RevokeSecurityGroupIngress_Call {
	_c.Call.Return(run)
	return _c
}

// RunInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RunInstances(ctx context.Context, params *ec2.RunInstancesInput, optFns ...func(*ec2.Options)) (*ec2.RunInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RunInstances")
	}

	var r0 *ec2.RunInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RunInstancesInput, ...func(*ec2.Options)) (*ec2.RunInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RunInstancesInput, ...func(*ec2.Options)) *ec2.RunInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RunInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RunInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RunInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunInstances'
type EC2_RunInstances_Call struct {
	*mock.Call
}

// RunInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RunInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RunInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RunInstances_Call {
	return &EC2_RunInstances_Call{Call: _e.mock.On("RunInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RunInstances_Call) Run(run func(ctx context.Context, params *ec2.RunInstancesInput, optFns ...func(*ec2.Options))) *EC2_RunInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RunInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RunInstances_Call) Return(_a0 *ec2.RunInstancesOutput, _a1 error) *EC2_RunInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RunInstances_Call) RunAndReturn(run func(context.Context, *ec2.RunInstancesInput, ...func(*ec2.Options)) (*ec2.RunInstancesOutput, error)) *EC2_RunInstances_Call {
	_c.Call.Return(run)
	return _c
}

// RunScheduledInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) RunScheduledInstances(ctx context.Context, params *ec2.RunScheduledInstancesInput, optFns ...func(*ec2.Options)) (*ec2.RunScheduledInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RunScheduledInstances")
	}

	var r0 *ec2.RunScheduledInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RunScheduledInstancesInput, ...func(*ec2.Options)) (*ec2.RunScheduledInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.RunScheduledInstancesInput, ...func(*ec2.Options)) *ec2.RunScheduledInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.RunScheduledInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.RunScheduledInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_RunScheduledInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunScheduledInstances'
type EC2_RunScheduledInstances_Call struct {
	*mock.Call
}

// RunScheduledInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.RunScheduledInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) RunScheduledInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_RunScheduledInstances_Call {
	return &EC2_RunScheduledInstances_Call{Call: _e.mock.On("RunScheduledInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_RunScheduledInstances_Call) Run(run func(ctx context.Context, params *ec2.RunScheduledInstancesInput, optFns ...func(*ec2.Options))) *EC2_RunScheduledInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.RunScheduledInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_RunScheduledInstances_Call) Return(_a0 *ec2.RunScheduledInstancesOutput, _a1 error) *EC2_RunScheduledInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_RunScheduledInstances_Call) RunAndReturn(run func(context.Context, *ec2.RunScheduledInstancesInput, ...func(*ec2.Options)) (*ec2.RunScheduledInstancesOutput, error)) *EC2_RunScheduledInstances_Call {
	_c.Call.Return(run)
	return _c
}

// SearchLocalGatewayRoutes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) SearchLocalGatewayRoutes(ctx context.Context, params *ec2.SearchLocalGatewayRoutesInput, optFns ...func(*ec2.Options)) (*ec2.SearchLocalGatewayRoutesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SearchLocalGatewayRoutes")
	}

	var r0 *ec2.SearchLocalGatewayRoutesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchLocalGatewayRoutesInput, ...func(*ec2.Options)) (*ec2.SearchLocalGatewayRoutesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchLocalGatewayRoutesInput, ...func(*ec2.Options)) *ec2.SearchLocalGatewayRoutesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchLocalGatewayRoutesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.SearchLocalGatewayRoutesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_SearchLocalGatewayRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchLocalGatewayRoutes'
type EC2_SearchLocalGatewayRoutes_Call struct {
	*mock.Call
}

// SearchLocalGatewayRoutes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.SearchLocalGatewayRoutesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) SearchLocalGatewayRoutes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_SearchLocalGatewayRoutes_Call {
	return &EC2_SearchLocalGatewayRoutes_Call{Call: _e.mock.On("SearchLocalGatewayRoutes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_SearchLocalGatewayRoutes_Call) Run(run func(ctx context.Context, params *ec2.SearchLocalGatewayRoutesInput, optFns ...func(*ec2.Options))) *EC2_SearchLocalGatewayRoutes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.SearchLocalGatewayRoutesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_SearchLocalGatewayRoutes_Call) Return(_a0 *ec2.SearchLocalGatewayRoutesOutput, _a1 error) *EC2_SearchLocalGatewayRoutes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_SearchLocalGatewayRoutes_Call) RunAndReturn(run func(context.Context, *ec2.SearchLocalGatewayRoutesInput, ...func(*ec2.Options)) (*ec2.SearchLocalGatewayRoutesOutput, error)) *EC2_SearchLocalGatewayRoutes_Call {
	_c.Call.Return(run)
	return _c
}

// SearchTransitGatewayMulticastGroups provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) SearchTransitGatewayMulticastGroups(ctx context.Context, params *ec2.SearchTransitGatewayMulticastGroupsInput, optFns ...func(*ec2.Options)) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SearchTransitGatewayMulticastGroups")
	}

	var r0 *ec2.SearchTransitGatewayMulticastGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchTransitGatewayMulticastGroupsInput, ...func(*ec2.Options)) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchTransitGatewayMulticastGroupsInput, ...func(*ec2.Options)) *ec2.SearchTransitGatewayMulticastGroupsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchTransitGatewayMulticastGroupsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.SearchTransitGatewayMulticastGroupsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_SearchTransitGatewayMulticastGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchTransitGatewayMulticastGroups'
type EC2_SearchTransitGatewayMulticastGroups_Call struct {
	*mock.Call
}

// SearchTransitGatewayMulticastGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.SearchTransitGatewayMulticastGroupsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) SearchTransitGatewayMulticastGroups(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_SearchTransitGatewayMulticastGroups_Call {
	return &EC2_SearchTransitGatewayMulticastGroups_Call{Call: _e.mock.On("SearchTransitGatewayMulticastGroups",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_SearchTransitGatewayMulticastGroups_Call) Run(run func(ctx context.Context, params *ec2.SearchTransitGatewayMulticastGroupsInput, optFns ...func(*ec2.Options))) *EC2_SearchTransitGatewayMulticastGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.SearchTransitGatewayMulticastGroupsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_SearchTransitGatewayMulticastGroups_Call) Return(_a0 *ec2.SearchTransitGatewayMulticastGroupsOutput, _a1 error) *EC2_SearchTransitGatewayMulticastGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_SearchTransitGatewayMulticastGroups_Call) RunAndReturn(run func(context.Context, *ec2.SearchTransitGatewayMulticastGroupsInput, ...func(*ec2.Options)) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error)) *EC2_SearchTransitGatewayMulticastGroups_Call {
	_c.Call.Return(run)
	return _c
}

// SearchTransitGatewayRoutes provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) SearchTransitGatewayRoutes(ctx context.Context, params *ec2.SearchTransitGatewayRoutesInput, optFns ...func(*ec2.Options)) (*ec2.SearchTransitGatewayRoutesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SearchTransitGatewayRoutes")
	}

	var r0 *ec2.SearchTransitGatewayRoutesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchTransitGatewayRoutesInput, ...func(*ec2.Options)) (*ec2.SearchTransitGatewayRoutesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SearchTransitGatewayRoutesInput, ...func(*ec2.Options)) *ec2.SearchTransitGatewayRoutesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SearchTransitGatewayRoutesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.SearchTransitGatewayRoutesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_SearchTransitGatewayRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchTransitGatewayRoutes'
type EC2_SearchTransitGatewayRoutes_Call struct {
	*mock.Call
}

// SearchTransitGatewayRoutes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.SearchTransitGatewayRoutesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) SearchTransitGatewayRoutes(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_SearchTransitGatewayRoutes_Call {
	return &EC2_SearchTransitGatewayRoutes_Call{Call: _e.mock.On("SearchTransitGatewayRoutes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_SearchTransitGatewayRoutes_Call) Run(run func(ctx context.Context, params *ec2.SearchTransitGatewayRoutesInput, optFns ...func(*ec2.Options))) *EC2_SearchTransitGatewayRoutes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.SearchTransitGatewayRoutesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_SearchTransitGatewayRoutes_Call) Return(_a0 *ec2.SearchTransitGatewayRoutesOutput, _a1 error) *EC2_SearchTransitGatewayRoutes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_SearchTransitGatewayRoutes_Call) RunAndReturn(run func(context.Context, *ec2.SearchTransitGatewayRoutesInput, ...func(*ec2.Options)) (*ec2.SearchTransitGatewayRoutesOutput, error)) *EC2_SearchTransitGatewayRoutes_Call {
	_c.Call.Return(run)
	return _c
}

// SendDiagnosticInterrupt provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) SendDiagnosticInterrupt(ctx context.Context, params *ec2.SendDiagnosticInterruptInput, optFns ...func(*ec2.Options)) (*ec2.SendDiagnosticInterruptOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SendDiagnosticInterrupt")
	}

	var r0 *ec2.SendDiagnosticInterruptOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SendDiagnosticInterruptInput, ...func(*ec2.Options)) (*ec2.SendDiagnosticInterruptOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.SendDiagnosticInterruptInput, ...func(*ec2.Options)) *ec2.SendDiagnosticInterruptOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.SendDiagnosticInterruptOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.SendDiagnosticInterruptInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_SendDiagnosticInterrupt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendDiagnosticInterrupt'
type EC2_SendDiagnosticInterrupt_Call struct {
	*mock.Call
}

// SendDiagnosticInterrupt is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.SendDiagnosticInterruptInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) SendDiagnosticInterrupt(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_SendDiagnosticInterrupt_Call {
	return &EC2_SendDiagnosticInterrupt_Call{Call: _e.mock.On("SendDiagnosticInterrupt",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_SendDiagnosticInterrupt_Call) Run(run func(ctx context.Context, params *ec2.SendDiagnosticInterruptInput, optFns ...func(*ec2.Options))) *EC2_SendDiagnosticInterrupt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.SendDiagnosticInterruptInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_SendDiagnosticInterrupt_Call) Return(_a0 *ec2.SendDiagnosticInterruptOutput, _a1 error) *EC2_SendDiagnosticInterrupt_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_SendDiagnosticInterrupt_Call) RunAndReturn(run func(context.Context, *ec2.SendDiagnosticInterruptInput, ...func(*ec2.Options)) (*ec2.SendDiagnosticInterruptOutput, error)) *EC2_SendDiagnosticInterrupt_Call {
	_c.Call.Return(run)
	return _c
}

// StartDeclarativePoliciesReport provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) StartDeclarativePoliciesReport(ctx context.Context, params *ec2.StartDeclarativePoliciesReportInput, optFns ...func(*ec2.Options)) (*ec2.StartDeclarativePoliciesReportOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartDeclarativePoliciesReport")
	}

	var r0 *ec2.StartDeclarativePoliciesReportOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartDeclarativePoliciesReportInput, ...func(*ec2.Options)) (*ec2.StartDeclarativePoliciesReportOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartDeclarativePoliciesReportInput, ...func(*ec2.Options)) *ec2.StartDeclarativePoliciesReportOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartDeclarativePoliciesReportOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StartDeclarativePoliciesReportInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_StartDeclarativePoliciesReport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartDeclarativePoliciesReport'
type EC2_StartDeclarativePoliciesReport_Call struct {
	*mock.Call
}

// StartDeclarativePoliciesReport is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.StartDeclarativePoliciesReportInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) StartDeclarativePoliciesReport(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_StartDeclarativePoliciesReport_Call {
	return &EC2_StartDeclarativePoliciesReport_Call{Call: _e.mock.On("StartDeclarativePoliciesReport",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_StartDeclarativePoliciesReport_Call) Run(run func(ctx context.Context, params *ec2.StartDeclarativePoliciesReportInput, optFns ...func(*ec2.Options))) *EC2_StartDeclarativePoliciesReport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.StartDeclarativePoliciesReportInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_StartDeclarativePoliciesReport_Call) Return(_a0 *ec2.StartDeclarativePoliciesReportOutput, _a1 error) *EC2_StartDeclarativePoliciesReport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_StartDeclarativePoliciesReport_Call) RunAndReturn(run func(context.Context, *ec2.StartDeclarativePoliciesReportInput, ...func(*ec2.Options)) (*ec2.StartDeclarativePoliciesReportOutput, error)) *EC2_StartDeclarativePoliciesReport_Call {
	_c.Call.Return(run)
	return _c
}

// StartInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) StartInstances(ctx context.Context, params *ec2.StartInstancesInput, optFns ...func(*ec2.Options)) (*ec2.StartInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartInstances")
	}

	var r0 *ec2.StartInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartInstancesInput, ...func(*ec2.Options)) (*ec2.StartInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartInstancesInput, ...func(*ec2.Options)) *ec2.StartInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StartInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_StartInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartInstances'
type EC2_StartInstances_Call struct {
	*mock.Call
}

// StartInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.StartInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) StartInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_StartInstances_Call {
	return &EC2_StartInstances_Call{Call: _e.mock.On("StartInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_StartInstances_Call) Run(run func(ctx context.Context, params *ec2.StartInstancesInput, optFns ...func(*ec2.Options))) *EC2_StartInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.StartInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_StartInstances_Call) Return(_a0 *ec2.StartInstancesOutput, _a1 error) *EC2_StartInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_StartInstances_Call) RunAndReturn(run func(context.Context, *ec2.StartInstancesInput, ...func(*ec2.Options)) (*ec2.StartInstancesOutput, error)) *EC2_StartInstances_Call {
	_c.Call.Return(run)
	return _c
}

// StartNetworkInsightsAccessScopeAnalysis provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) StartNetworkInsightsAccessScopeAnalysis(ctx context.Context, params *ec2.StartNetworkInsightsAccessScopeAnalysisInput, optFns ...func(*ec2.Options)) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartNetworkInsightsAccessScopeAnalysis")
	}

	var r0 *ec2.StartNetworkInsightsAccessScopeAnalysisOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartNetworkInsightsAccessScopeAnalysisInput, ...func(*ec2.Options)) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartNetworkInsightsAccessScopeAnalysisInput, ...func(*ec2.Options)) *ec2.StartNetworkInsightsAccessScopeAnalysisOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StartNetworkInsightsAccessScopeAnalysisInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_StartNetworkInsightsAccessScopeAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartNetworkInsightsAccessScopeAnalysis'
type EC2_StartNetworkInsightsAccessScopeAnalysis_Call struct {
	*mock.Call
}

// StartNetworkInsightsAccessScopeAnalysis is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.StartNetworkInsightsAccessScopeAnalysisInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) StartNetworkInsightsAccessScopeAnalysis(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_StartNetworkInsightsAccessScopeAnalysis_Call {
	return &EC2_StartNetworkInsightsAccessScopeAnalysis_Call{Call: _e.mock.On("StartNetworkInsightsAccessScopeAnalysis",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_StartNetworkInsightsAccessScopeAnalysis_Call) Run(run func(ctx context.Context, params *ec2.StartNetworkInsightsAccessScopeAnalysisInput, optFns ...func(*ec2.Options))) *EC2_StartNetworkInsightsAccessScopeAnalysis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.StartNetworkInsightsAccessScopeAnalysisInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_StartNetworkInsightsAccessScopeAnalysis_Call) Return(_a0 *ec2.StartNetworkInsightsAccessScopeAnalysisOutput, _a1 error) *EC2_StartNetworkInsightsAccessScopeAnalysis_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_StartNetworkInsightsAccessScopeAnalysis_Call) RunAndReturn(run func(context.Context, *ec2.StartNetworkInsightsAccessScopeAnalysisInput, ...func(*ec2.Options)) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error)) *EC2_StartNetworkInsightsAccessScopeAnalysis_Call {
	_c.Call.Return(run)
	return _c
}

// StartNetworkInsightsAnalysis provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) StartNetworkInsightsAnalysis(ctx context.Context, params *ec2.StartNetworkInsightsAnalysisInput, optFns ...func(*ec2.Options)) (*ec2.StartNetworkInsightsAnalysisOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartNetworkInsightsAnalysis")
	}

	var r0 *ec2.StartNetworkInsightsAnalysisOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartNetworkInsightsAnalysisInput, ...func(*ec2.Options)) (*ec2.StartNetworkInsightsAnalysisOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartNetworkInsightsAnalysisInput, ...func(*ec2.Options)) *ec2.StartNetworkInsightsAnalysisOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartNetworkInsightsAnalysisOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StartNetworkInsightsAnalysisInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_StartNetworkInsightsAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartNetworkInsightsAnalysis'
type EC2_StartNetworkInsightsAnalysis_Call struct {
	*mock.Call
}

// StartNetworkInsightsAnalysis is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.StartNetworkInsightsAnalysisInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) StartNetworkInsightsAnalysis(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_StartNetworkInsightsAnalysis_Call {
	return &EC2_StartNetworkInsightsAnalysis_Call{Call: _e.mock.On("StartNetworkInsightsAnalysis",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_StartNetworkInsightsAnalysis_Call) Run(run func(ctx context.Context, params *ec2.StartNetworkInsightsAnalysisInput, optFns ...func(*ec2.Options))) *EC2_StartNetworkInsightsAnalysis_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.StartNetworkInsightsAnalysisInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_StartNetworkInsightsAnalysis_Call) Return(_a0 *ec2.StartNetworkInsightsAnalysisOutput, _a1 error) *EC2_StartNetworkInsightsAnalysis_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_StartNetworkInsightsAnalysis_Call) RunAndReturn(run func(context.Context, *ec2.StartNetworkInsightsAnalysisInput, ...func(*ec2.Options)) (*ec2.StartNetworkInsightsAnalysisOutput, error)) *EC2_StartNetworkInsightsAnalysis_Call {
	_c.Call.Return(run)
	return _c
}

// StartVpcEndpointServicePrivateDnsVerification provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) StartVpcEndpointServicePrivateDnsVerification(ctx context.Context, params *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, optFns ...func(*ec2.Options)) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartVpcEndpointServicePrivateDnsVerification")
	}

	var r0 *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, ...func(*ec2.Options)) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, ...func(*ec2.Options)) *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_StartVpcEndpointServicePrivateDnsVerification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartVpcEndpointServicePrivateDnsVerification'
type EC2_StartVpcEndpointServicePrivateDnsVerification_Call struct {
	*mock.Call
}

// StartVpcEndpointServicePrivateDnsVerification is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.StartVpcEndpointServicePrivateDnsVerificationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) StartVpcEndpointServicePrivateDnsVerification(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_StartVpcEndpointServicePrivateDnsVerification_Call {
	return &EC2_StartVpcEndpointServicePrivateDnsVerification_Call{Call: _e.mock.On("StartVpcEndpointServicePrivateDnsVerification",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_StartVpcEndpointServicePrivateDnsVerification_Call) Run(run func(ctx context.Context, params *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, optFns ...func(*ec2.Options))) *EC2_StartVpcEndpointServicePrivateDnsVerification_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.StartVpcEndpointServicePrivateDnsVerificationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_StartVpcEndpointServicePrivateDnsVerification_Call) Return(_a0 *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, _a1 error) *EC2_StartVpcEndpointServicePrivateDnsVerification_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_StartVpcEndpointServicePrivateDnsVerification_Call) RunAndReturn(run func(context.Context, *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, ...func(*ec2.Options)) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error)) *EC2_StartVpcEndpointServicePrivateDnsVerification_Call {
	_c.Call.Return(run)
	return _c
}

// StopInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) StopInstances(ctx context.Context, params *ec2.StopInstancesInput, optFns ...func(*ec2.Options)) (*ec2.StopInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StopInstances")
	}

	var r0 *ec2.StopInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StopInstancesInput, ...func(*ec2.Options)) (*ec2.StopInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.StopInstancesInput, ...func(*ec2.Options)) *ec2.StopInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.StopInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.StopInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_StopInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopInstances'
type EC2_StopInstances_Call struct {
	*mock.Call
}

// StopInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.StopInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) StopInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_StopInstances_Call {
	return &EC2_StopInstances_Call{Call: _e.mock.On("StopInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_StopInstances_Call) Run(run func(ctx context.Context, params *ec2.StopInstancesInput, optFns ...func(*ec2.Options))) *EC2_StopInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.StopInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_StopInstances_Call) Return(_a0 *ec2.StopInstancesOutput, _a1 error) *EC2_StopInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_StopInstances_Call) RunAndReturn(run func(context.Context, *ec2.StopInstancesInput, ...func(*ec2.Options)) (*ec2.StopInstancesOutput, error)) *EC2_StopInstances_Call {
	_c.Call.Return(run)
	return _c
}

// TerminateClientVpnConnections provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) TerminateClientVpnConnections(ctx context.Context, params *ec2.TerminateClientVpnConnectionsInput, optFns ...func(*ec2.Options)) (*ec2.TerminateClientVpnConnectionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for TerminateClientVpnConnections")
	}

	var r0 *ec2.TerminateClientVpnConnectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.TerminateClientVpnConnectionsInput, ...func(*ec2.Options)) (*ec2.TerminateClientVpnConnectionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.TerminateClientVpnConnectionsInput, ...func(*ec2.Options)) *ec2.TerminateClientVpnConnectionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.TerminateClientVpnConnectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.TerminateClientVpnConnectionsInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_TerminateClientVpnConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TerminateClientVpnConnections'
type EC2_TerminateClientVpnConnections_Call struct {
	*mock.Call
}

// TerminateClientVpnConnections is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.TerminateClientVpnConnectionsInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) TerminateClientVpnConnections(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_TerminateClientVpnConnections_Call {
	return &EC2_TerminateClientVpnConnections_Call{Call: _e.mock.On("TerminateClientVpnConnections",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_TerminateClientVpnConnections_Call) Run(run func(ctx context.Context, params *ec2.TerminateClientVpnConnectionsInput, optFns ...func(*ec2.Options))) *EC2_TerminateClientVpnConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.TerminateClientVpnConnectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_TerminateClientVpnConnections_Call) Return(_a0 *ec2.TerminateClientVpnConnectionsOutput, _a1 error) *EC2_TerminateClientVpnConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_TerminateClientVpnConnections_Call) RunAndReturn(run func(context.Context, *ec2.TerminateClientVpnConnectionsInput, ...func(*ec2.Options)) (*ec2.TerminateClientVpnConnectionsOutput, error)) *EC2_TerminateClientVpnConnections_Call {
	_c.Call.Return(run)
	return _c
}

// TerminateInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) TerminateInstances(ctx context.Context, params *ec2.TerminateInstancesInput, optFns ...func(*ec2.Options)) (*ec2.TerminateInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for TerminateInstances")
	}

	var r0 *ec2.TerminateInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.TerminateInstancesInput, ...func(*ec2.Options)) (*ec2.TerminateInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.TerminateInstancesInput, ...func(*ec2.Options)) *ec2.TerminateInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.TerminateInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.TerminateInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_TerminateInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TerminateInstances'
type EC2_TerminateInstances_Call struct {
	*mock.Call
}

// TerminateInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.TerminateInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) TerminateInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_TerminateInstances_Call {
	return &EC2_TerminateInstances_Call{Call: _e.mock.On("TerminateInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_TerminateInstances_Call) Run(run func(ctx context.Context, params *ec2.TerminateInstancesInput, optFns ...func(*ec2.Options))) *EC2_TerminateInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.TerminateInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_TerminateInstances_Call) Return(_a0 *ec2.TerminateInstancesOutput, _a1 error) *EC2_TerminateInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_TerminateInstances_Call) RunAndReturn(run func(context.Context, *ec2.TerminateInstancesInput, ...func(*ec2.Options)) (*ec2.TerminateInstancesOutput, error)) *EC2_TerminateInstances_Call {
	_c.Call.Return(run)
	return _c
}

// UnassignIpv6Addresses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UnassignIpv6Addresses(ctx context.Context, params *ec2.UnassignIpv6AddressesInput, optFns ...func(*ec2.Options)) (*ec2.UnassignIpv6AddressesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UnassignIpv6Addresses")
	}

	var r0 *ec2.UnassignIpv6AddressesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnassignIpv6AddressesInput, ...func(*ec2.Options)) (*ec2.UnassignIpv6AddressesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnassignIpv6AddressesInput, ...func(*ec2.Options)) *ec2.UnassignIpv6AddressesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnassignIpv6AddressesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UnassignIpv6AddressesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UnassignIpv6Addresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnassignIpv6Addresses'
type EC2_UnassignIpv6Addresses_Call struct {
	*mock.Call
}

// UnassignIpv6Addresses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UnassignIpv6AddressesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UnassignIpv6Addresses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UnassignIpv6Addresses_Call {
	return &EC2_UnassignIpv6Addresses_Call{Call: _e.mock.On("UnassignIpv6Addresses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UnassignIpv6Addresses_Call) Run(run func(ctx context.Context, params *ec2.UnassignIpv6AddressesInput, optFns ...func(*ec2.Options))) *EC2_UnassignIpv6Addresses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UnassignIpv6AddressesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UnassignIpv6Addresses_Call) Return(_a0 *ec2.UnassignIpv6AddressesOutput, _a1 error) *EC2_UnassignIpv6Addresses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UnassignIpv6Addresses_Call) RunAndReturn(run func(context.Context, *ec2.UnassignIpv6AddressesInput, ...func(*ec2.Options)) (*ec2.UnassignIpv6AddressesOutput, error)) *EC2_UnassignIpv6Addresses_Call {
	_c.Call.Return(run)
	return _c
}

// UnassignPrivateIpAddresses provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UnassignPrivateIpAddresses(ctx context.Context, params *ec2.UnassignPrivateIpAddressesInput, optFns ...func(*ec2.Options)) (*ec2.UnassignPrivateIpAddressesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UnassignPrivateIpAddresses")
	}

	var r0 *ec2.UnassignPrivateIpAddressesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnassignPrivateIpAddressesInput, ...func(*ec2.Options)) (*ec2.UnassignPrivateIpAddressesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnassignPrivateIpAddressesInput, ...func(*ec2.Options)) *ec2.UnassignPrivateIpAddressesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnassignPrivateIpAddressesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UnassignPrivateIpAddressesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UnassignPrivateIpAddresses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnassignPrivateIpAddresses'
type EC2_UnassignPrivateIpAddresses_Call struct {
	*mock.Call
}

// UnassignPrivateIpAddresses is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UnassignPrivateIpAddressesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UnassignPrivateIpAddresses(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UnassignPrivateIpAddresses_Call {
	return &EC2_UnassignPrivateIpAddresses_Call{Call: _e.mock.On("UnassignPrivateIpAddresses",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UnassignPrivateIpAddresses_Call) Run(run func(ctx context.Context, params *ec2.UnassignPrivateIpAddressesInput, optFns ...func(*ec2.Options))) *EC2_UnassignPrivateIpAddresses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UnassignPrivateIpAddressesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UnassignPrivateIpAddresses_Call) Return(_a0 *ec2.UnassignPrivateIpAddressesOutput, _a1 error) *EC2_UnassignPrivateIpAddresses_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UnassignPrivateIpAddresses_Call) RunAndReturn(run func(context.Context, *ec2.UnassignPrivateIpAddressesInput, ...func(*ec2.Options)) (*ec2.UnassignPrivateIpAddressesOutput, error)) *EC2_UnassignPrivateIpAddresses_Call {
	_c.Call.Return(run)
	return _c
}

// UnassignPrivateNatGatewayAddress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UnassignPrivateNatGatewayAddress(ctx context.Context, params *ec2.UnassignPrivateNatGatewayAddressInput, optFns ...func(*ec2.Options)) (*ec2.UnassignPrivateNatGatewayAddressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UnassignPrivateNatGatewayAddress")
	}

	var r0 *ec2.UnassignPrivateNatGatewayAddressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnassignPrivateNatGatewayAddressInput, ...func(*ec2.Options)) (*ec2.UnassignPrivateNatGatewayAddressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnassignPrivateNatGatewayAddressInput, ...func(*ec2.Options)) *ec2.UnassignPrivateNatGatewayAddressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnassignPrivateNatGatewayAddressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UnassignPrivateNatGatewayAddressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UnassignPrivateNatGatewayAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnassignPrivateNatGatewayAddress'
type EC2_UnassignPrivateNatGatewayAddress_Call struct {
	*mock.Call
}

// UnassignPrivateNatGatewayAddress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UnassignPrivateNatGatewayAddressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UnassignPrivateNatGatewayAddress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UnassignPrivateNatGatewayAddress_Call {
	return &EC2_UnassignPrivateNatGatewayAddress_Call{Call: _e.mock.On("UnassignPrivateNatGatewayAddress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UnassignPrivateNatGatewayAddress_Call) Run(run func(ctx context.Context, params *ec2.UnassignPrivateNatGatewayAddressInput, optFns ...func(*ec2.Options))) *EC2_UnassignPrivateNatGatewayAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UnassignPrivateNatGatewayAddressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UnassignPrivateNatGatewayAddress_Call) Return(_a0 *ec2.UnassignPrivateNatGatewayAddressOutput, _a1 error) *EC2_UnassignPrivateNatGatewayAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UnassignPrivateNatGatewayAddress_Call) RunAndReturn(run func(context.Context, *ec2.UnassignPrivateNatGatewayAddressInput, ...func(*ec2.Options)) (*ec2.UnassignPrivateNatGatewayAddressOutput, error)) *EC2_UnassignPrivateNatGatewayAddress_Call {
	_c.Call.Return(run)
	return _c
}

// UnlockSnapshot provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UnlockSnapshot(ctx context.Context, params *ec2.UnlockSnapshotInput, optFns ...func(*ec2.Options)) (*ec2.UnlockSnapshotOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UnlockSnapshot")
	}

	var r0 *ec2.UnlockSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnlockSnapshotInput, ...func(*ec2.Options)) (*ec2.UnlockSnapshotOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnlockSnapshotInput, ...func(*ec2.Options)) *ec2.UnlockSnapshotOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnlockSnapshotOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UnlockSnapshotInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UnlockSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnlockSnapshot'
type EC2_UnlockSnapshot_Call struct {
	*mock.Call
}

// UnlockSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UnlockSnapshotInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UnlockSnapshot(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UnlockSnapshot_Call {
	return &EC2_UnlockSnapshot_Call{Call: _e.mock.On("UnlockSnapshot",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UnlockSnapshot_Call) Run(run func(ctx context.Context, params *ec2.UnlockSnapshotInput, optFns ...func(*ec2.Options))) *EC2_UnlockSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UnlockSnapshotInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UnlockSnapshot_Call) Return(_a0 *ec2.UnlockSnapshotOutput, _a1 error) *EC2_UnlockSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UnlockSnapshot_Call) RunAndReturn(run func(context.Context, *ec2.UnlockSnapshotInput, ...func(*ec2.Options)) (*ec2.UnlockSnapshotOutput, error)) *EC2_UnlockSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// UnmonitorInstances provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UnmonitorInstances(ctx context.Context, params *ec2.UnmonitorInstancesInput, optFns ...func(*ec2.Options)) (*ec2.UnmonitorInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UnmonitorInstances")
	}

	var r0 *ec2.UnmonitorInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnmonitorInstancesInput, ...func(*ec2.Options)) (*ec2.UnmonitorInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UnmonitorInstancesInput, ...func(*ec2.Options)) *ec2.UnmonitorInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UnmonitorInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UnmonitorInstancesInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UnmonitorInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnmonitorInstances'
type EC2_UnmonitorInstances_Call struct {
	*mock.Call
}

// UnmonitorInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UnmonitorInstancesInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UnmonitorInstances(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UnmonitorInstances_Call {
	return &EC2_UnmonitorInstances_Call{Call: _e.mock.On("UnmonitorInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UnmonitorInstances_Call) Run(run func(ctx context.Context, params *ec2.UnmonitorInstancesInput, optFns ...func(*ec2.Options))) *EC2_UnmonitorInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UnmonitorInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UnmonitorInstances_Call) Return(_a0 *ec2.UnmonitorInstancesOutput, _a1 error) *EC2_UnmonitorInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UnmonitorInstances_Call) RunAndReturn(run func(context.Context, *ec2.UnmonitorInstancesInput, ...func(*ec2.Options)) (*ec2.UnmonitorInstancesOutput, error)) *EC2_UnmonitorInstances_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateCapacityManagerOrganizationsAccess provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UpdateCapacityManagerOrganizationsAccess(ctx context.Context, params *ec2.UpdateCapacityManagerOrganizationsAccessInput, optFns ...func(*ec2.Options)) (*ec2.UpdateCapacityManagerOrganizationsAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateCapacityManagerOrganizationsAccess")
	}

	var r0 *ec2.UpdateCapacityManagerOrganizationsAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateCapacityManagerOrganizationsAccessInput, ...func(*ec2.Options)) (*ec2.UpdateCapacityManagerOrganizationsAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateCapacityManagerOrganizationsAccessInput, ...func(*ec2.Options)) *ec2.UpdateCapacityManagerOrganizationsAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UpdateCapacityManagerOrganizationsAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UpdateCapacityManagerOrganizationsAccessInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UpdateCapacityManagerOrganizationsAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateCapacityManagerOrganizationsAccess'
type EC2_UpdateCapacityManagerOrganizationsAccess_Call struct {
	*mock.Call
}

// UpdateCapacityManagerOrganizationsAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UpdateCapacityManagerOrganizationsAccessInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UpdateCapacityManagerOrganizationsAccess(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UpdateCapacityManagerOrganizationsAccess_Call {
	return &EC2_UpdateCapacityManagerOrganizationsAccess_Call{Call: _e.mock.On("UpdateCapacityManagerOrganizationsAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UpdateCapacityManagerOrganizationsAccess_Call) Run(run func(ctx context.Context, params *ec2.UpdateCapacityManagerOrganizationsAccessInput, optFns ...func(*ec2.Options))) *EC2_UpdateCapacityManagerOrganizationsAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UpdateCapacityManagerOrganizationsAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UpdateCapacityManagerOrganizationsAccess_Call) Return(_a0 *ec2.UpdateCapacityManagerOrganizationsAccessOutput, _a1 error) *EC2_UpdateCapacityManagerOrganizationsAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UpdateCapacityManagerOrganizationsAccess_Call) RunAndReturn(run func(context.Context, *ec2.UpdateCapacityManagerOrganizationsAccessInput, ...func(*ec2.Options)) (*ec2.UpdateCapacityManagerOrganizationsAccessOutput, error)) *EC2_UpdateCapacityManagerOrganizationsAccess_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateInterruptibleCapacityReservationAllocation provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UpdateInterruptibleCapacityReservationAllocation(ctx context.Context, params *ec2.UpdateInterruptibleCapacityReservationAllocationInput, optFns ...func(*ec2.Options)) (*ec2.UpdateInterruptibleCapacityReservationAllocationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateInterruptibleCapacityReservationAllocation")
	}

	var r0 *ec2.UpdateInterruptibleCapacityReservationAllocationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) (*ec2.UpdateInterruptibleCapacityReservationAllocationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) *ec2.UpdateInterruptibleCapacityReservationAllocationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UpdateInterruptibleCapacityReservationAllocationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UpdateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UpdateInterruptibleCapacityReservationAllocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateInterruptibleCapacityReservationAllocation'
type EC2_UpdateInterruptibleCapacityReservationAllocation_Call struct {
	*mock.Call
}

// UpdateInterruptibleCapacityReservationAllocation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UpdateInterruptibleCapacityReservationAllocationInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UpdateInterruptibleCapacityReservationAllocation(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UpdateInterruptibleCapacityReservationAllocation_Call {
	return &EC2_UpdateInterruptibleCapacityReservationAllocation_Call{Call: _e.mock.On("UpdateInterruptibleCapacityReservationAllocation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UpdateInterruptibleCapacityReservationAllocation_Call) Run(run func(ctx context.Context, params *ec2.UpdateInterruptibleCapacityReservationAllocationInput, optFns ...func(*ec2.Options))) *EC2_UpdateInterruptibleCapacityReservationAllocation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UpdateInterruptibleCapacityReservationAllocationInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UpdateInterruptibleCapacityReservationAllocation_Call) Return(_a0 *ec2.UpdateInterruptibleCapacityReservationAllocationOutput, _a1 error) *EC2_UpdateInterruptibleCapacityReservationAllocation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UpdateInterruptibleCapacityReservationAllocation_Call) RunAndReturn(run func(context.Context, *ec2.UpdateInterruptibleCapacityReservationAllocationInput, ...func(*ec2.Options)) (*ec2.UpdateInterruptibleCapacityReservationAllocationOutput, error)) *EC2_UpdateInterruptibleCapacityReservationAllocation_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSecurityGroupRuleDescriptionsEgress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UpdateSecurityGroupRuleDescriptionsEgress(ctx context.Context, params *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, optFns ...func(*ec2.Options)) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateSecurityGroupRuleDescriptionsEgress")
	}

	var r0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, ...func(*ec2.Options)) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, ...func(*ec2.Options)) *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSecurityGroupRuleDescriptionsEgress'
type EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call struct {
	*mock.Call
}

// UpdateSecurityGroupRuleDescriptionsEgress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UpdateSecurityGroupRuleDescriptionsEgress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call {
	return &EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call{Call: _e.mock.On("UpdateSecurityGroupRuleDescriptionsEgress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call) Run(run func(ctx context.Context, params *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, optFns ...func(*ec2.Options))) *EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call) Return(_a0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, _a1 error) *EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call) RunAndReturn(run func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, ...func(*ec2.Options)) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error)) *EC2_UpdateSecurityGroupRuleDescriptionsEgress_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSecurityGroupRuleDescriptionsIngress provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) UpdateSecurityGroupRuleDescriptionsIngress(ctx context.Context, params *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, optFns ...func(*ec2.Options)) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateSecurityGroupRuleDescriptionsIngress")
	}

	var r0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, ...func(*ec2.Options)) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, ...func(*ec2.Options)) *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSecurityGroupRuleDescriptionsIngress'
type EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call struct {
	*mock.Call
}

// UpdateSecurityGroupRuleDescriptionsIngress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) UpdateSecurityGroupRuleDescriptionsIngress(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call {
	return &EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call{Call: _e.mock.On("UpdateSecurityGroupRuleDescriptionsIngress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call) Run(run func(ctx context.Context, params *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, optFns ...func(*ec2.Options))) *EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call) Return(_a0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, _a1 error) *EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call) RunAndReturn(run func(context.Context, *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, ...func(*ec2.Options)) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error)) *EC2_UpdateSecurityGroupRuleDescriptionsIngress_Call {
	_c.Call.Return(run)
	return _c
}

// WithdrawByoipCidr provides a mock function with given fields: ctx, params, optFns
func (_m *EC2) WithdrawByoipCidr(ctx context.Context, params *ec2.WithdrawByoipCidrInput, optFns ...func(*ec2.Options)) (*ec2.WithdrawByoipCidrOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for WithdrawByoipCidr")
	}

	var r0 *ec2.WithdrawByoipCidrOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.WithdrawByoipCidrInput, ...func(*ec2.Options)) (*ec2.WithdrawByoipCidrOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ec2.WithdrawByoipCidrInput, ...func(*ec2.Options)) *ec2.WithdrawByoipCidrOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ec2.WithdrawByoipCidrOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ec2.WithdrawByoipCidrInput, ...func(*ec2.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EC2_WithdrawByoipCidr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithdrawByoipCidr'
type EC2_WithdrawByoipCidr_Call struct {
	*mock.Call
}

// WithdrawByoipCidr is a helper method to define mock.On call
//   - ctx context.Context
//   - params *ec2.WithdrawByoipCidrInput
//   - optFns ...func(*ec2.Options)
func (_e *EC2_Expecter) WithdrawByoipCidr(ctx interface{}, params interface{}, optFns ...interface{}) *EC2_WithdrawByoipCidr_Call {
	return &EC2_WithdrawByoipCidr_Call{Call: _e.mock.On("WithdrawByoipCidr",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *EC2_WithdrawByoipCidr_Call) Run(run func(ctx context.Context, params *ec2.WithdrawByoipCidrInput, optFns ...func(*ec2.Options))) *EC2_WithdrawByoipCidr_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*ec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*ec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*ec2.WithdrawByoipCidrInput), variadicArgs...)
	})
	return _c
}

func (_c *EC2_WithdrawByoipCidr_Call) Return(_a0 *ec2.WithdrawByoipCidrOutput, _a1 error) *EC2_WithdrawByoipCidr_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *EC2_WithdrawByoipCidr_Call) RunAndReturn(run func(context.Context, *ec2.WithdrawByoipCidrInput, ...func(*ec2.Options)) (*ec2.WithdrawByoipCidrOutput, error)) *EC2_WithdrawByoipCidr_Call {
	_c.Call.Return(run)
	return _c
}

// NewEC2 creates a new instance of EC2. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewEC2(t interface {
	mock.TestingT
	Cleanup(func())
}) *EC2 {
	mock := &EC2{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
