// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/ec2/ec2iface (interfaces: EC2API)

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

import (
	context "context"
	reflect "reflect"

	request "github.com/aws/aws-sdk-go/aws/request"
	ec2 "github.com/aws/aws-sdk-go/service/ec2"
	gomock "github.com/golang/mock/gomock"
)

// MockEC2API is a mock of EC2API interface.
type MockEC2API struct {
	ctrl     *gomock.Controller
	recorder *MockEC2APIMockRecorder
}

// MockEC2APIMockRecorder is the mock recorder for MockEC2API.
type MockEC2APIMockRecorder struct {
	mock *MockEC2API
}

// NewMockEC2API creates a new mock instance.
func NewMockEC2API(ctrl *gomock.Controller) *MockEC2API {
	mock := &MockEC2API{ctrl: ctrl}
	mock.recorder = &MockEC2APIMockRecorder{mock}
	return mock
}

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

// AcceptAddressTransfer mocks base method.
func (m *MockEC2API) AcceptAddressTransfer(arg0 *ec2.AcceptAddressTransferInput) (*ec2.AcceptAddressTransferOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptAddressTransfer", arg0)
	ret0, _ := ret[0].(*ec2.AcceptAddressTransferOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptAddressTransfer indicates an expected call of AcceptAddressTransfer.
func (mr *MockEC2APIMockRecorder) AcceptAddressTransfer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptAddressTransfer", reflect.TypeOf((*MockEC2API)(nil).AcceptAddressTransfer), arg0)
}

// AcceptAddressTransferRequest mocks base method.
func (m *MockEC2API) AcceptAddressTransferRequest(arg0 *ec2.AcceptAddressTransferInput) (*request.Request, *ec2.AcceptAddressTransferOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptAddressTransferRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AcceptAddressTransferOutput)
	return ret0, ret1
}

// AcceptAddressTransferRequest indicates an expected call of AcceptAddressTransferRequest.
func (mr *MockEC2APIMockRecorder) AcceptAddressTransferRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptAddressTransferRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptAddressTransferRequest), arg0)
}

// AcceptAddressTransferWithContext mocks base method.
func (m *MockEC2API) AcceptAddressTransferWithContext(arg0 context.Context, arg1 *ec2.AcceptAddressTransferInput, arg2 ...request.Option) (*ec2.AcceptAddressTransferOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptAddressTransferWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AcceptAddressTransferOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcceptReservedInstancesExchangeQuote mocks base method.
func (m *MockEC2API) AcceptReservedInstancesExchangeQuote(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuote", arg0)
	ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptReservedInstancesExchangeQuote indicates an expected call of AcceptReservedInstancesExchangeQuote.
func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuote), arg0)
}

// AcceptReservedInstancesExchangeQuoteRequest mocks base method.
func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteRequest(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.AcceptReservedInstancesExchangeQuoteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
	return ret0, ret1
}

// AcceptReservedInstancesExchangeQuoteRequest indicates an expected call of AcceptReservedInstancesExchangeQuoteRequest.
func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteRequest), arg0)
}

// AcceptReservedInstancesExchangeQuoteWithContext mocks base method.
func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteWithContext(arg0 context.Context, arg1 *ec2.AcceptReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcceptTransitGatewayMulticastDomainAssociations mocks base method.
func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociations(arg0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociations", arg0)
	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptTransitGatewayMulticastDomainAssociations indicates an expected call of AcceptTransitGatewayMulticastDomainAssociations.
func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayMulticastDomainAssociations), arg0)
}

// AcceptTransitGatewayMulticastDomainAssociationsRequest mocks base method.
func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
	return ret0, ret1
}

// AcceptTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of AcceptTransitGatewayMulticastDomainAssociationsRequest.
func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayMulticastDomainAssociationsRequest), arg0)
}

// AcceptTransitGatewayMulticastDomainAssociationsWithContext mocks base method.
func (m *MockEC2API) AcceptTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptTransitGatewayMulticastDomainAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayMulticastDomainAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcceptTransitGatewayPeeringAttachment mocks base method.
func (m *MockEC2API) AcceptTransitGatewayPeeringAttachment(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachment", arg0)
	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptTransitGatewayPeeringAttachment indicates an expected call of AcceptTransitGatewayPeeringAttachment.
func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachment), arg0)
}

// AcceptTransitGatewayPeeringAttachmentRequest mocks base method.
func (m *MockEC2API) AcceptTransitGatewayPeeringAttachmentRequest(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayPeeringAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
	return ret0, ret1
}

// AcceptTransitGatewayPeeringAttachmentRequest indicates an expected call of AcceptTransitGatewayPeeringAttachmentRequest.
func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachmentRequest), arg0)
}

// AcceptTransitGatewayPeeringAttachmentWithContext mocks base method.
func (m *MockEC2API) AcceptTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcceptTransitGatewayVpcAttachment mocks base method.
func (m *MockEC2API) AcceptTransitGatewayVpcAttachment(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachment", arg0)
	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptTransitGatewayVpcAttachment indicates an expected call of AcceptTransitGatewayVpcAttachment.
func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachment), arg0)
}

// AcceptTransitGatewayVpcAttachmentRequest mocks base method.
func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentRequest(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayVpcAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
	return ret0, ret1
}

// AcceptTransitGatewayVpcAttachmentRequest indicates an expected call of AcceptTransitGatewayVpcAttachmentRequest.
func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentRequest), arg0)
}

// AcceptTransitGatewayVpcAttachmentWithContext mocks base method.
func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcceptVpcEndpointConnections mocks base method.
func (m *MockEC2API) AcceptVpcEndpointConnections(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*ec2.AcceptVpcEndpointConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptVpcEndpointConnections", arg0)
	ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptVpcEndpointConnections indicates an expected call of AcceptVpcEndpointConnections.
func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnections(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnections), arg0)
}

// AcceptVpcEndpointConnectionsRequest mocks base method.
func (m *MockEC2API) AcceptVpcEndpointConnectionsRequest(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*request.Request, *ec2.AcceptVpcEndpointConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AcceptVpcEndpointConnectionsOutput)
	return ret0, ret1
}

// AcceptVpcEndpointConnectionsRequest indicates an expected call of AcceptVpcEndpointConnectionsRequest.
func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnectionsRequest), arg0)
}

// AcceptVpcEndpointConnectionsWithContext mocks base method.
func (m *MockEC2API) AcceptVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.AcceptVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.AcceptVpcEndpointConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AcceptVpcPeeringConnection mocks base method.
func (m *MockEC2API) AcceptVpcPeeringConnection(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*ec2.AcceptVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptVpcPeeringConnection", arg0)
	ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcceptVpcPeeringConnection indicates an expected call of AcceptVpcPeeringConnection.
func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnection), arg0)
}

// AcceptVpcPeeringConnectionRequest mocks base method.
func (m *MockEC2API) AcceptVpcPeeringConnectionRequest(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*request.Request, *ec2.AcceptVpcPeeringConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AcceptVpcPeeringConnectionOutput)
	return ret0, ret1
}

// AcceptVpcPeeringConnectionRequest indicates an expected call of AcceptVpcPeeringConnectionRequest.
func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionRequest), arg0)
}

// AcceptVpcPeeringConnectionWithContext mocks base method.
func (m *MockEC2API) AcceptVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.AcceptVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.AcceptVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AdvertiseByoipCidr mocks base method.
func (m *MockEC2API) AdvertiseByoipCidr(arg0 *ec2.AdvertiseByoipCidrInput) (*ec2.AdvertiseByoipCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AdvertiseByoipCidr", arg0)
	ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AdvertiseByoipCidr indicates an expected call of AdvertiseByoipCidr.
func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidr", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidr), arg0)
}

// AdvertiseByoipCidrRequest mocks base method.
func (m *MockEC2API) AdvertiseByoipCidrRequest(arg0 *ec2.AdvertiseByoipCidrInput) (*request.Request, *ec2.AdvertiseByoipCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AdvertiseByoipCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AdvertiseByoipCidrOutput)
	return ret0, ret1
}

// AdvertiseByoipCidrRequest indicates an expected call of AdvertiseByoipCidrRequest.
func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrRequest), arg0)
}

// AdvertiseByoipCidrWithContext mocks base method.
func (m *MockEC2API) AdvertiseByoipCidrWithContext(arg0 context.Context, arg1 *ec2.AdvertiseByoipCidrInput, arg2 ...request.Option) (*ec2.AdvertiseByoipCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AdvertiseByoipCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AllocateAddress mocks base method.
func (m *MockEC2API) AllocateAddress(arg0 *ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllocateAddress", arg0)
	ret0, _ := ret[0].(*ec2.AllocateAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllocateAddress indicates an expected call of AllocateAddress.
func (mr *MockEC2APIMockRecorder) AllocateAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddress", reflect.TypeOf((*MockEC2API)(nil).AllocateAddress), arg0)
}

// AllocateAddressRequest mocks base method.
func (m *MockEC2API) AllocateAddressRequest(arg0 *ec2.AllocateAddressInput) (*request.Request, *ec2.AllocateAddressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllocateAddressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AllocateAddressOutput)
	return ret0, ret1
}

// AllocateAddressRequest indicates an expected call of AllocateAddressRequest.
func (mr *MockEC2APIMockRecorder) AllocateAddressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressRequest), arg0)
}

// AllocateAddressWithContext mocks base method.
func (m *MockEC2API) AllocateAddressWithContext(arg0 context.Context, arg1 *ec2.AllocateAddressInput, arg2 ...request.Option) (*ec2.AllocateAddressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AllocateAddressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AllocateAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AllocateHosts mocks base method.
func (m *MockEC2API) AllocateHosts(arg0 *ec2.AllocateHostsInput) (*ec2.AllocateHostsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllocateHosts", arg0)
	ret0, _ := ret[0].(*ec2.AllocateHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllocateHosts indicates an expected call of AllocateHosts.
func (mr *MockEC2APIMockRecorder) AllocateHosts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHosts", reflect.TypeOf((*MockEC2API)(nil).AllocateHosts), arg0)
}

// AllocateHostsRequest mocks base method.
func (m *MockEC2API) AllocateHostsRequest(arg0 *ec2.AllocateHostsInput) (*request.Request, *ec2.AllocateHostsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllocateHostsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AllocateHostsOutput)
	return ret0, ret1
}

// AllocateHostsRequest indicates an expected call of AllocateHostsRequest.
func (mr *MockEC2APIMockRecorder) AllocateHostsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsRequest), arg0)
}

// AllocateHostsWithContext mocks base method.
func (m *MockEC2API) AllocateHostsWithContext(arg0 context.Context, arg1 *ec2.AllocateHostsInput, arg2 ...request.Option) (*ec2.AllocateHostsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AllocateHostsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AllocateHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AllocateIpamPoolCidr mocks base method.
func (m *MockEC2API) AllocateIpamPoolCidr(arg0 *ec2.AllocateIpamPoolCidrInput) (*ec2.AllocateIpamPoolCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllocateIpamPoolCidr", arg0)
	ret0, _ := ret[0].(*ec2.AllocateIpamPoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllocateIpamPoolCidr indicates an expected call of AllocateIpamPoolCidr.
func (mr *MockEC2APIMockRecorder) AllocateIpamPoolCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateIpamPoolCidr", reflect.TypeOf((*MockEC2API)(nil).AllocateIpamPoolCidr), arg0)
}

// AllocateIpamPoolCidrRequest mocks base method.
func (m *MockEC2API) AllocateIpamPoolCidrRequest(arg0 *ec2.AllocateIpamPoolCidrInput) (*request.Request, *ec2.AllocateIpamPoolCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllocateIpamPoolCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AllocateIpamPoolCidrOutput)
	return ret0, ret1
}

// AllocateIpamPoolCidrRequest indicates an expected call of AllocateIpamPoolCidrRequest.
func (mr *MockEC2APIMockRecorder) AllocateIpamPoolCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateIpamPoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateIpamPoolCidrRequest), arg0)
}

// AllocateIpamPoolCidrWithContext mocks base method.
func (m *MockEC2API) AllocateIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.AllocateIpamPoolCidrInput, arg2 ...request.Option) (*ec2.AllocateIpamPoolCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AllocateIpamPoolCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AllocateIpamPoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ApplySecurityGroupsToClientVpnTargetNetwork mocks base method.
func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetwork", arg0)
	ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplySecurityGroupsToClientVpnTargetNetwork indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetwork.
func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetwork), arg0)
}

// ApplySecurityGroupsToClientVpnTargetNetworkRequest mocks base method.
func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*request.Request, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
	return ret0, ret1
}

// ApplySecurityGroupsToClientVpnTargetNetworkRequest indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkRequest.
func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkRequest), arg0)
}

// ApplySecurityGroupsToClientVpnTargetNetworkWithContext mocks base method.
func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssignIpv6Addresses mocks base method.
func (m *MockEC2API) AssignIpv6Addresses(arg0 *ec2.AssignIpv6AddressesInput) (*ec2.AssignIpv6AddressesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignIpv6Addresses", arg0)
	ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssignIpv6Addresses indicates an expected call of AssignIpv6Addresses.
func (mr *MockEC2APIMockRecorder) AssignIpv6Addresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6Addresses), arg0)
}

// AssignIpv6AddressesRequest mocks base method.
func (m *MockEC2API) AssignIpv6AddressesRequest(arg0 *ec2.AssignIpv6AddressesInput) (*request.Request, *ec2.AssignIpv6AddressesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignIpv6AddressesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssignIpv6AddressesOutput)
	return ret0, ret1
}

// AssignIpv6AddressesRequest indicates an expected call of AssignIpv6AddressesRequest.
func (mr *MockEC2APIMockRecorder) AssignIpv6AddressesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesRequest), arg0)
}

// AssignIpv6AddressesWithContext mocks base method.
func (m *MockEC2API) AssignIpv6AddressesWithContext(arg0 context.Context, arg1 *ec2.AssignIpv6AddressesInput, arg2 ...request.Option) (*ec2.AssignIpv6AddressesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssignIpv6AddressesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssignPrivateIpAddresses mocks base method.
func (m *MockEC2API) AssignPrivateIpAddresses(arg0 *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignPrivateIpAddresses", arg0)
	ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssignPrivateIpAddresses indicates an expected call of AssignPrivateIpAddresses.
func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddresses), arg0)
}

// AssignPrivateIpAddressesRequest mocks base method.
func (m *MockEC2API) AssignPrivateIpAddressesRequest(arg0 *ec2.AssignPrivateIpAddressesInput) (*request.Request, *ec2.AssignPrivateIpAddressesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignPrivateIpAddressesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssignPrivateIpAddressesOutput)
	return ret0, ret1
}

// AssignPrivateIpAddressesRequest indicates an expected call of AssignPrivateIpAddressesRequest.
func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesRequest), arg0)
}

// AssignPrivateIpAddressesWithContext mocks base method.
func (m *MockEC2API) AssignPrivateIpAddressesWithContext(arg0 context.Context, arg1 *ec2.AssignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.AssignPrivateIpAddressesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssignPrivateIpAddressesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssignPrivateNatGatewayAddress mocks base method.
func (m *MockEC2API) AssignPrivateNatGatewayAddress(arg0 *ec2.AssignPrivateNatGatewayAddressInput) (*ec2.AssignPrivateNatGatewayAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddress", arg0)
	ret0, _ := ret[0].(*ec2.AssignPrivateNatGatewayAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssignPrivateNatGatewayAddress indicates an expected call of AssignPrivateNatGatewayAddress.
func (mr *MockEC2APIMockRecorder) AssignPrivateNatGatewayAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateNatGatewayAddress), arg0)
}

// AssignPrivateNatGatewayAddressRequest mocks base method.
func (m *MockEC2API) AssignPrivateNatGatewayAddressRequest(arg0 *ec2.AssignPrivateNatGatewayAddressInput) (*request.Request, *ec2.AssignPrivateNatGatewayAddressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssignPrivateNatGatewayAddressOutput)
	return ret0, ret1
}

// AssignPrivateNatGatewayAddressRequest indicates an expected call of AssignPrivateNatGatewayAddressRequest.
func (mr *MockEC2APIMockRecorder) AssignPrivateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateNatGatewayAddressRequest), arg0)
}

// AssignPrivateNatGatewayAddressWithContext mocks base method.
func (m *MockEC2API) AssignPrivateNatGatewayAddressWithContext(arg0 context.Context, arg1 *ec2.AssignPrivateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.AssignPrivateNatGatewayAddressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssignPrivateNatGatewayAddressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssignPrivateNatGatewayAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateAddress mocks base method.
func (m *MockEC2API) AssociateAddress(arg0 *ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateAddress", arg0)
	ret0, _ := ret[0].(*ec2.AssociateAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateAddress indicates an expected call of AssociateAddress.
func (mr *MockEC2APIMockRecorder) AssociateAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateAddress), arg0)
}

// AssociateAddressRequest mocks base method.
func (m *MockEC2API) AssociateAddressRequest(arg0 *ec2.AssociateAddressInput) (*request.Request, *ec2.AssociateAddressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateAddressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateAddressOutput)
	return ret0, ret1
}

// AssociateAddressRequest indicates an expected call of AssociateAddressRequest.
func (mr *MockEC2APIMockRecorder) AssociateAddressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateAddressRequest), arg0)
}

// AssociateAddressWithContext mocks base method.
func (m *MockEC2API) AssociateAddressWithContext(arg0 context.Context, arg1 *ec2.AssociateAddressInput, arg2 ...request.Option) (*ec2.AssociateAddressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateAddressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateClientVpnTargetNetwork mocks base method.
func (m *MockEC2API) AssociateClientVpnTargetNetwork(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*ec2.AssociateClientVpnTargetNetworkOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetwork", arg0)
	ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateClientVpnTargetNetwork indicates an expected call of AssociateClientVpnTargetNetwork.
func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetwork), arg0)
}

// AssociateClientVpnTargetNetworkRequest mocks base method.
func (m *MockEC2API) AssociateClientVpnTargetNetworkRequest(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*request.Request, *ec2.AssociateClientVpnTargetNetworkOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateClientVpnTargetNetworkOutput)
	return ret0, ret1
}

// AssociateClientVpnTargetNetworkRequest indicates an expected call of AssociateClientVpnTargetNetworkRequest.
func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetworkRequest), arg0)
}

// AssociateClientVpnTargetNetworkWithContext mocks base method.
func (m *MockEC2API) AssociateClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.AssociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.AssociateClientVpnTargetNetworkOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateDhcpOptions mocks base method.
func (m *MockEC2API) AssociateDhcpOptions(arg0 *ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateDhcpOptions", arg0)
	ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateDhcpOptions indicates an expected call of AssociateDhcpOptions.
func (mr *MockEC2APIMockRecorder) AssociateDhcpOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptions), arg0)
}

// AssociateDhcpOptionsRequest mocks base method.
func (m *MockEC2API) AssociateDhcpOptionsRequest(arg0 *ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateDhcpOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateDhcpOptionsOutput)
	return ret0, ret1
}

// AssociateDhcpOptionsRequest indicates an expected call of AssociateDhcpOptionsRequest.
func (mr *MockEC2APIMockRecorder) AssociateDhcpOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsRequest), arg0)
}

// AssociateDhcpOptionsWithContext mocks base method.
func (m *MockEC2API) AssociateDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.AssociateDhcpOptionsInput, arg2 ...request.Option) (*ec2.AssociateDhcpOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateDhcpOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateEnclaveCertificateIamRole mocks base method.
func (m *MockEC2API) AssociateEnclaveCertificateIamRole(arg0 *ec2.AssociateEnclaveCertificateIamRoleInput) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRole", arg0)
	ret0, _ := ret[0].(*ec2.AssociateEnclaveCertificateIamRoleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateEnclaveCertificateIamRole indicates an expected call of AssociateEnclaveCertificateIamRole.
func (mr *MockEC2APIMockRecorder) AssociateEnclaveCertificateIamRole(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEnclaveCertificateIamRole", reflect.TypeOf((*MockEC2API)(nil).AssociateEnclaveCertificateIamRole), arg0)
}

// AssociateEnclaveCertificateIamRoleRequest mocks base method.
func (m *MockEC2API) AssociateEnclaveCertificateIamRoleRequest(arg0 *ec2.AssociateEnclaveCertificateIamRoleInput) (*request.Request, *ec2.AssociateEnclaveCertificateIamRoleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRoleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateEnclaveCertificateIamRoleOutput)
	return ret0, ret1
}

// AssociateEnclaveCertificateIamRoleRequest indicates an expected call of AssociateEnclaveCertificateIamRoleRequest.
func (mr *MockEC2APIMockRecorder) AssociateEnclaveCertificateIamRoleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEnclaveCertificateIamRoleRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateEnclaveCertificateIamRoleRequest), arg0)
}

// AssociateEnclaveCertificateIamRoleWithContext mocks base method.
func (m *MockEC2API) AssociateEnclaveCertificateIamRoleWithContext(arg0 context.Context, arg1 *ec2.AssociateEnclaveCertificateIamRoleInput, arg2 ...request.Option) (*ec2.AssociateEnclaveCertificateIamRoleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateEnclaveCertificateIamRoleWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateEnclaveCertificateIamRoleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateIamInstanceProfile mocks base method.
func (m *MockEC2API) AssociateIamInstanceProfile(arg0 *ec2.AssociateIamInstanceProfileInput) (*ec2.AssociateIamInstanceProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateIamInstanceProfile", arg0)
	ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateIamInstanceProfile indicates an expected call of AssociateIamInstanceProfile.
func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfile(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfile), arg0)
}

// AssociateIamInstanceProfileRequest mocks base method.
func (m *MockEC2API) AssociateIamInstanceProfileRequest(arg0 *ec2.AssociateIamInstanceProfileInput) (*request.Request, *ec2.AssociateIamInstanceProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateIamInstanceProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateIamInstanceProfileOutput)
	return ret0, ret1
}

// AssociateIamInstanceProfileRequest indicates an expected call of AssociateIamInstanceProfileRequest.
func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfileRequest), arg0)
}

// AssociateIamInstanceProfileWithContext mocks base method.
func (m *MockEC2API) AssociateIamInstanceProfileWithContext(arg0 context.Context, arg1 *ec2.AssociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.AssociateIamInstanceProfileOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateIamInstanceProfileWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateInstanceEventWindow mocks base method.
func (m *MockEC2API) AssociateInstanceEventWindow(arg0 *ec2.AssociateInstanceEventWindowInput) (*ec2.AssociateInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateInstanceEventWindow", arg0)
	ret0, _ := ret[0].(*ec2.AssociateInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateInstanceEventWindow indicates an expected call of AssociateInstanceEventWindow.
func (mr *MockEC2APIMockRecorder) AssociateInstanceEventWindow(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).AssociateInstanceEventWindow), arg0)
}

// AssociateInstanceEventWindowRequest mocks base method.
func (m *MockEC2API) AssociateInstanceEventWindowRequest(arg0 *ec2.AssociateInstanceEventWindowInput) (*request.Request, *ec2.AssociateInstanceEventWindowOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateInstanceEventWindowRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateInstanceEventWindowOutput)
	return ret0, ret1
}

// AssociateInstanceEventWindowRequest indicates an expected call of AssociateInstanceEventWindowRequest.
func (mr *MockEC2APIMockRecorder) AssociateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateInstanceEventWindowRequest), arg0)
}

// AssociateInstanceEventWindowWithContext mocks base method.
func (m *MockEC2API) AssociateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.AssociateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.AssociateInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateInstanceEventWindowWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateIpamByoasn mocks base method.
func (m *MockEC2API) AssociateIpamByoasn(arg0 *ec2.AssociateIpamByoasnInput) (*ec2.AssociateIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateIpamByoasn", arg0)
	ret0, _ := ret[0].(*ec2.AssociateIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateIpamByoasn indicates an expected call of AssociateIpamByoasn.
func (mr *MockEC2APIMockRecorder) AssociateIpamByoasn(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamByoasn), arg0)
}

// AssociateIpamByoasnRequest mocks base method.
func (m *MockEC2API) AssociateIpamByoasnRequest(arg0 *ec2.AssociateIpamByoasnInput) (*request.Request, *ec2.AssociateIpamByoasnOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateIpamByoasnRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateIpamByoasnOutput)
	return ret0, ret1
}

// AssociateIpamByoasnRequest indicates an expected call of AssociateIpamByoasnRequest.
func (mr *MockEC2APIMockRecorder) AssociateIpamByoasnRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamByoasnRequest), arg0)
}

// AssociateIpamByoasnWithContext mocks base method.
func (m *MockEC2API) AssociateIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.AssociateIpamByoasnInput, arg2 ...request.Option) (*ec2.AssociateIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateIpamByoasnWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateIpamResourceDiscovery mocks base method.
func (m *MockEC2API) AssociateIpamResourceDiscovery(arg0 *ec2.AssociateIpamResourceDiscoveryInput) (*ec2.AssociateIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateIpamResourceDiscovery", arg0)
	ret0, _ := ret[0].(*ec2.AssociateIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateIpamResourceDiscovery indicates an expected call of AssociateIpamResourceDiscovery.
func (mr *MockEC2APIMockRecorder) AssociateIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamResourceDiscovery), arg0)
}

// AssociateIpamResourceDiscoveryRequest mocks base method.
func (m *MockEC2API) AssociateIpamResourceDiscoveryRequest(arg0 *ec2.AssociateIpamResourceDiscoveryInput) (*request.Request, *ec2.AssociateIpamResourceDiscoveryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateIpamResourceDiscoveryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateIpamResourceDiscoveryOutput)
	return ret0, ret1
}

// AssociateIpamResourceDiscoveryRequest indicates an expected call of AssociateIpamResourceDiscoveryRequest.
func (mr *MockEC2APIMockRecorder) AssociateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIpamResourceDiscoveryRequest), arg0)
}

// AssociateIpamResourceDiscoveryWithContext mocks base method.
func (m *MockEC2API) AssociateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.AssociateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.AssociateIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateIpamResourceDiscoveryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateNatGatewayAddress mocks base method.
func (m *MockEC2API) AssociateNatGatewayAddress(arg0 *ec2.AssociateNatGatewayAddressInput) (*ec2.AssociateNatGatewayAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateNatGatewayAddress", arg0)
	ret0, _ := ret[0].(*ec2.AssociateNatGatewayAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateNatGatewayAddress indicates an expected call of AssociateNatGatewayAddress.
func (mr *MockEC2APIMockRecorder) AssociateNatGatewayAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateNatGatewayAddress), arg0)
}

// AssociateNatGatewayAddressRequest mocks base method.
func (m *MockEC2API) AssociateNatGatewayAddressRequest(arg0 *ec2.AssociateNatGatewayAddressInput) (*request.Request, *ec2.AssociateNatGatewayAddressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateNatGatewayAddressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateNatGatewayAddressOutput)
	return ret0, ret1
}

// AssociateNatGatewayAddressRequest indicates an expected call of AssociateNatGatewayAddressRequest.
func (mr *MockEC2APIMockRecorder) AssociateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateNatGatewayAddressRequest), arg0)
}

// AssociateNatGatewayAddressWithContext mocks base method.
func (m *MockEC2API) AssociateNatGatewayAddressWithContext(arg0 context.Context, arg1 *ec2.AssociateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.AssociateNatGatewayAddressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateNatGatewayAddressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateNatGatewayAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateRouteTable mocks base method.
func (m *MockEC2API) AssociateRouteTable(arg0 *ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateRouteTable indicates an expected call of AssociateRouteTable.
func (mr *MockEC2APIMockRecorder) AssociateRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTable), arg0)
}

// AssociateRouteTableRequest mocks base method.
func (m *MockEC2API) AssociateRouteTableRequest(arg0 *ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateRouteTableOutput)
	return ret0, ret1
}

// AssociateRouteTableRequest indicates an expected call of AssociateRouteTableRequest.
func (mr *MockEC2APIMockRecorder) AssociateRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTableRequest), arg0)
}

// AssociateRouteTableWithContext mocks base method.
func (m *MockEC2API) AssociateRouteTableWithContext(arg0 context.Context, arg1 *ec2.AssociateRouteTableInput, arg2 ...request.Option) (*ec2.AssociateRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateSubnetCidrBlock mocks base method.
func (m *MockEC2API) AssociateSubnetCidrBlock(arg0 *ec2.AssociateSubnetCidrBlockInput) (*ec2.AssociateSubnetCidrBlockOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateSubnetCidrBlock", arg0)
	ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateSubnetCidrBlock indicates an expected call of AssociateSubnetCidrBlock.
func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlock), arg0)
}

// AssociateSubnetCidrBlockRequest mocks base method.
func (m *MockEC2API) AssociateSubnetCidrBlockRequest(arg0 *ec2.AssociateSubnetCidrBlockInput) (*request.Request, *ec2.AssociateSubnetCidrBlockOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateSubnetCidrBlockOutput)
	return ret0, ret1
}

// AssociateSubnetCidrBlockRequest indicates an expected call of AssociateSubnetCidrBlockRequest.
func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlockRequest), arg0)
}

// AssociateSubnetCidrBlockWithContext mocks base method.
func (m *MockEC2API) AssociateSubnetCidrBlockWithContext(arg0 context.Context, arg1 *ec2.AssociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateSubnetCidrBlockOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateTransitGatewayMulticastDomain mocks base method.
func (m *MockEC2API) AssociateTransitGatewayMulticastDomain(arg0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomain", arg0)
	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayMulticastDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateTransitGatewayMulticastDomain indicates an expected call of AssociateTransitGatewayMulticastDomain.
func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomain), arg0)
}

// AssociateTransitGatewayMulticastDomainRequest mocks base method.
func (m *MockEC2API) AssociateTransitGatewayMulticastDomainRequest(arg0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.AssociateTransitGatewayMulticastDomainOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomainRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateTransitGatewayMulticastDomainOutput)
	return ret0, ret1
}

// AssociateTransitGatewayMulticastDomainRequest indicates an expected call of AssociateTransitGatewayMulticastDomainRequest.
func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomainRequest), arg0)
}

// AssociateTransitGatewayMulticastDomainWithContext mocks base method.
func (m *MockEC2API) AssociateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomainWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayMulticastDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateTransitGatewayPolicyTable mocks base method.
func (m *MockEC2API) AssociateTransitGatewayPolicyTable(arg0 *ec2.AssociateTransitGatewayPolicyTableInput) (*ec2.AssociateTransitGatewayPolicyTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTable", arg0)
	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayPolicyTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateTransitGatewayPolicyTable indicates an expected call of AssociateTransitGatewayPolicyTable.
func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayPolicyTable), arg0)
}

// AssociateTransitGatewayPolicyTableRequest mocks base method.
func (m *MockEC2API) AssociateTransitGatewayPolicyTableRequest(arg0 *ec2.AssociateTransitGatewayPolicyTableInput) (*request.Request, *ec2.AssociateTransitGatewayPolicyTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateTransitGatewayPolicyTableOutput)
	return ret0, ret1
}

// AssociateTransitGatewayPolicyTableRequest indicates an expected call of AssociateTransitGatewayPolicyTableRequest.
func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayPolicyTableRequest), arg0)
}

// AssociateTransitGatewayPolicyTableWithContext mocks base method.
func (m *MockEC2API) AssociateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayPolicyTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayPolicyTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateTransitGatewayRouteTable mocks base method.
func (m *MockEC2API) AssociateTransitGatewayRouteTable(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*ec2.AssociateTransitGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateTransitGatewayRouteTable indicates an expected call of AssociateTransitGatewayRouteTable.
func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTable), arg0)
}

// AssociateTransitGatewayRouteTableRequest mocks base method.
func (m *MockEC2API) AssociateTransitGatewayRouteTableRequest(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*request.Request, *ec2.AssociateTransitGatewayRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateTransitGatewayRouteTableOutput)
	return ret0, ret1
}

// AssociateTransitGatewayRouteTableRequest indicates an expected call of AssociateTransitGatewayRouteTableRequest.
func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableRequest), arg0)
}

// AssociateTransitGatewayRouteTableWithContext mocks base method.
func (m *MockEC2API) AssociateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateTrunkInterface mocks base method.
func (m *MockEC2API) AssociateTrunkInterface(arg0 *ec2.AssociateTrunkInterfaceInput) (*ec2.AssociateTrunkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTrunkInterface", arg0)
	ret0, _ := ret[0].(*ec2.AssociateTrunkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateTrunkInterface indicates an expected call of AssociateTrunkInterface.
func (mr *MockEC2APIMockRecorder) AssociateTrunkInterface(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterface", reflect.TypeOf((*MockEC2API)(nil).AssociateTrunkInterface), arg0)
}

// AssociateTrunkInterfaceRequest mocks base method.
func (m *MockEC2API) AssociateTrunkInterfaceRequest(arg0 *ec2.AssociateTrunkInterfaceInput) (*request.Request, *ec2.AssociateTrunkInterfaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateTrunkInterfaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateTrunkInterfaceOutput)
	return ret0, ret1
}

// AssociateTrunkInterfaceRequest indicates an expected call of AssociateTrunkInterfaceRequest.
func (mr *MockEC2APIMockRecorder) AssociateTrunkInterfaceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTrunkInterfaceRequest), arg0)
}

// AssociateTrunkInterfaceWithContext mocks base method.
func (m *MockEC2API) AssociateTrunkInterfaceWithContext(arg0 context.Context, arg1 *ec2.AssociateTrunkInterfaceInput, arg2 ...request.Option) (*ec2.AssociateTrunkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateTrunkInterfaceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateTrunkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateVpcCidrBlock mocks base method.
func (m *MockEC2API) AssociateVpcCidrBlock(arg0 *ec2.AssociateVpcCidrBlockInput) (*ec2.AssociateVpcCidrBlockOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateVpcCidrBlock", arg0)
	ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateVpcCidrBlock indicates an expected call of AssociateVpcCidrBlock.
func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlock), arg0)
}

// AssociateVpcCidrBlockRequest mocks base method.
func (m *MockEC2API) AssociateVpcCidrBlockRequest(arg0 *ec2.AssociateVpcCidrBlockInput) (*request.Request, *ec2.AssociateVpcCidrBlockOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateVpcCidrBlockRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AssociateVpcCidrBlockOutput)
	return ret0, ret1
}

// AssociateVpcCidrBlockRequest indicates an expected call of AssociateVpcCidrBlockRequest.
func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlockRequest), arg0)
}

// AssociateVpcCidrBlockWithContext mocks base method.
func (m *MockEC2API) AssociateVpcCidrBlockWithContext(arg0 context.Context, arg1 *ec2.AssociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateVpcCidrBlockOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateVpcCidrBlockWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AttachClassicLinkVpc mocks base method.
func (m *MockEC2API) AttachClassicLinkVpc(arg0 *ec2.AttachClassicLinkVpcInput) (*ec2.AttachClassicLinkVpcOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachClassicLinkVpc", arg0)
	ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachClassicLinkVpc indicates an expected call of AttachClassicLinkVpc.
func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpc), arg0)
}

// AttachClassicLinkVpcRequest mocks base method.
func (m *MockEC2API) AttachClassicLinkVpcRequest(arg0 *ec2.AttachClassicLinkVpcInput) (*request.Request, *ec2.AttachClassicLinkVpcOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachClassicLinkVpcRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AttachClassicLinkVpcOutput)
	return ret0, ret1
}

// AttachClassicLinkVpcRequest indicates an expected call of AttachClassicLinkVpcRequest.
func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpcRequest), arg0)
}

// AttachClassicLinkVpcWithContext mocks base method.
func (m *MockEC2API) AttachClassicLinkVpcWithContext(arg0 context.Context, arg1 *ec2.AttachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.AttachClassicLinkVpcOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AttachClassicLinkVpcWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AttachInternetGateway mocks base method.
func (m *MockEC2API) AttachInternetGateway(arg0 *ec2.AttachInternetGatewayInput) (*ec2.AttachInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachInternetGateway", arg0)
	ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachInternetGateway indicates an expected call of AttachInternetGateway.
func (mr *MockEC2APIMockRecorder) AttachInternetGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGateway), arg0)
}

// AttachInternetGatewayRequest mocks base method.
func (m *MockEC2API) AttachInternetGatewayRequest(arg0 *ec2.AttachInternetGatewayInput) (*request.Request, *ec2.AttachInternetGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachInternetGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AttachInternetGatewayOutput)
	return ret0, ret1
}

// AttachInternetGatewayRequest indicates an expected call of AttachInternetGatewayRequest.
func (mr *MockEC2APIMockRecorder) AttachInternetGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGatewayRequest), arg0)
}

// AttachInternetGatewayWithContext mocks base method.
func (m *MockEC2API) AttachInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.AttachInternetGatewayInput, arg2 ...request.Option) (*ec2.AttachInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AttachInternetGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AttachNetworkInterface mocks base method.
func (m *MockEC2API) AttachNetworkInterface(arg0 *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachNetworkInterface", arg0)
	ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachNetworkInterface indicates an expected call of AttachNetworkInterface.
func (mr *MockEC2APIMockRecorder) AttachNetworkInterface(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterface), arg0)
}

// AttachNetworkInterfaceRequest mocks base method.
func (m *MockEC2API) AttachNetworkInterfaceRequest(arg0 *ec2.AttachNetworkInterfaceInput) (*request.Request, *ec2.AttachNetworkInterfaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachNetworkInterfaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AttachNetworkInterfaceOutput)
	return ret0, ret1
}

// AttachNetworkInterfaceRequest indicates an expected call of AttachNetworkInterfaceRequest.
func (mr *MockEC2APIMockRecorder) AttachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterfaceRequest), arg0)
}

// AttachNetworkInterfaceWithContext mocks base method.
func (m *MockEC2API) AttachNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.AttachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.AttachNetworkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AttachNetworkInterfaceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AttachVerifiedAccessTrustProvider mocks base method.
func (m *MockEC2API) AttachVerifiedAccessTrustProvider(arg0 *ec2.AttachVerifiedAccessTrustProviderInput) (*ec2.AttachVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProvider", arg0)
	ret0, _ := ret[0].(*ec2.AttachVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachVerifiedAccessTrustProvider indicates an expected call of AttachVerifiedAccessTrustProvider.
func (mr *MockEC2APIMockRecorder) AttachVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).AttachVerifiedAccessTrustProvider), arg0)
}

// AttachVerifiedAccessTrustProviderRequest mocks base method.
func (m *MockEC2API) AttachVerifiedAccessTrustProviderRequest(arg0 *ec2.AttachVerifiedAccessTrustProviderInput) (*request.Request, *ec2.AttachVerifiedAccessTrustProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AttachVerifiedAccessTrustProviderOutput)
	return ret0, ret1
}

// AttachVerifiedAccessTrustProviderRequest indicates an expected call of AttachVerifiedAccessTrustProviderRequest.
func (mr *MockEC2APIMockRecorder) AttachVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVerifiedAccessTrustProviderRequest), arg0)
}

// AttachVerifiedAccessTrustProviderWithContext mocks base method.
func (m *MockEC2API) AttachVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.AttachVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.AttachVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProviderWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AttachVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AttachVolume mocks base method.
func (m *MockEC2API) AttachVolume(arg0 *ec2.AttachVolumeInput) (*ec2.VolumeAttachment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachVolume", arg0)
	ret0, _ := ret[0].(*ec2.VolumeAttachment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachVolume indicates an expected call of AttachVolume.
func (mr *MockEC2APIMockRecorder) AttachVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolume", reflect.TypeOf((*MockEC2API)(nil).AttachVolume), arg0)
}

// AttachVolumeRequest mocks base method.
func (m *MockEC2API) AttachVolumeRequest(arg0 *ec2.AttachVolumeInput) (*request.Request, *ec2.VolumeAttachment) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachVolumeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.VolumeAttachment)
	return ret0, ret1
}

// AttachVolumeRequest indicates an expected call of AttachVolumeRequest.
func (mr *MockEC2APIMockRecorder) AttachVolumeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVolumeRequest), arg0)
}

// AttachVolumeWithContext mocks base method.
func (m *MockEC2API) AttachVolumeWithContext(arg0 context.Context, arg1 *ec2.AttachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AttachVolumeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.VolumeAttachment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AttachVpnGateway mocks base method.
func (m *MockEC2API) AttachVpnGateway(arg0 *ec2.AttachVpnGatewayInput) (*ec2.AttachVpnGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachVpnGateway", arg0)
	ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachVpnGateway indicates an expected call of AttachVpnGateway.
func (mr *MockEC2APIMockRecorder) AttachVpnGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGateway), arg0)
}

// AttachVpnGatewayRequest mocks base method.
func (m *MockEC2API) AttachVpnGatewayRequest(arg0 *ec2.AttachVpnGatewayInput) (*request.Request, *ec2.AttachVpnGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachVpnGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AttachVpnGatewayOutput)
	return ret0, ret1
}

// AttachVpnGatewayRequest indicates an expected call of AttachVpnGatewayRequest.
func (mr *MockEC2APIMockRecorder) AttachVpnGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGatewayRequest), arg0)
}

// AttachVpnGatewayWithContext mocks base method.
func (m *MockEC2API) AttachVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.AttachVpnGatewayInput, arg2 ...request.Option) (*ec2.AttachVpnGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AttachVpnGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AuthorizeClientVpnIngress mocks base method.
func (m *MockEC2API) AuthorizeClientVpnIngress(arg0 *ec2.AuthorizeClientVpnIngressInput) (*ec2.AuthorizeClientVpnIngressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeClientVpnIngress", arg0)
	ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeClientVpnIngress indicates an expected call of AuthorizeClientVpnIngress.
func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngress), arg0)
}

// AuthorizeClientVpnIngressRequest mocks base method.
func (m *MockEC2API) AuthorizeClientVpnIngressRequest(arg0 *ec2.AuthorizeClientVpnIngressInput) (*request.Request, *ec2.AuthorizeClientVpnIngressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AuthorizeClientVpnIngressOutput)
	return ret0, ret1
}

// AuthorizeClientVpnIngressRequest indicates an expected call of AuthorizeClientVpnIngressRequest.
func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngressRequest), arg0)
}

// AuthorizeClientVpnIngressWithContext mocks base method.
func (m *MockEC2API) AuthorizeClientVpnIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeClientVpnIngressInput, arg2 ...request.Option) (*ec2.AuthorizeClientVpnIngressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AuthorizeSecurityGroupEgress mocks base method.
func (m *MockEC2API) AuthorizeSecurityGroupEgress(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgress", arg0)
	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeSecurityGroupEgress indicates an expected call of AuthorizeSecurityGroupEgress.
func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgress), arg0)
}

// AuthorizeSecurityGroupEgressRequest mocks base method.
func (m *MockEC2API) AuthorizeSecurityGroupEgressRequest(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*request.Request, *ec2.AuthorizeSecurityGroupEgressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupEgressOutput)
	return ret0, ret1
}

// AuthorizeSecurityGroupEgressRequest indicates an expected call of AuthorizeSecurityGroupEgressRequest.
func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgressRequest), arg0)
}

// AuthorizeSecurityGroupEgressWithContext mocks base method.
func (m *MockEC2API) AuthorizeSecurityGroupEgressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AuthorizeSecurityGroupIngress mocks base method.
func (m *MockEC2API) AuthorizeSecurityGroupIngress(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngress", arg0)
	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeSecurityGroupIngress indicates an expected call of AuthorizeSecurityGroupIngress.
func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngress), arg0)
}

// AuthorizeSecurityGroupIngressRequest mocks base method.
func (m *MockEC2API) AuthorizeSecurityGroupIngressRequest(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*request.Request, *ec2.AuthorizeSecurityGroupIngressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupIngressOutput)
	return ret0, ret1
}

// AuthorizeSecurityGroupIngressRequest indicates an expected call of AuthorizeSecurityGroupIngressRequest.
func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngressRequest), arg0)
}

// AuthorizeSecurityGroupIngressWithContext mocks base method.
func (m *MockEC2API) AuthorizeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BundleInstance mocks base method.
func (m *MockEC2API) BundleInstance(arg0 *ec2.BundleInstanceInput) (*ec2.BundleInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BundleInstance", arg0)
	ret0, _ := ret[0].(*ec2.BundleInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BundleInstance indicates an expected call of BundleInstance.
func (mr *MockEC2APIMockRecorder) BundleInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstance", reflect.TypeOf((*MockEC2API)(nil).BundleInstance), arg0)
}

// BundleInstanceRequest mocks base method.
func (m *MockEC2API) BundleInstanceRequest(arg0 *ec2.BundleInstanceInput) (*request.Request, *ec2.BundleInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BundleInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.BundleInstanceOutput)
	return ret0, ret1
}

// BundleInstanceRequest indicates an expected call of BundleInstanceRequest.
func (mr *MockEC2APIMockRecorder) BundleInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).BundleInstanceRequest), arg0)
}

// BundleInstanceWithContext mocks base method.
func (m *MockEC2API) BundleInstanceWithContext(arg0 context.Context, arg1 *ec2.BundleInstanceInput, arg2 ...request.Option) (*ec2.BundleInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BundleInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.BundleInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelBundleTask mocks base method.
func (m *MockEC2API) CancelBundleTask(arg0 *ec2.CancelBundleTaskInput) (*ec2.CancelBundleTaskOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelBundleTask", arg0)
	ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelBundleTask indicates an expected call of CancelBundleTask.
func (mr *MockEC2APIMockRecorder) CancelBundleTask(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTask", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTask), arg0)
}

// CancelBundleTaskRequest mocks base method.
func (m *MockEC2API) CancelBundleTaskRequest(arg0 *ec2.CancelBundleTaskInput) (*request.Request, *ec2.CancelBundleTaskOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelBundleTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelBundleTaskOutput)
	return ret0, ret1
}

// CancelBundleTaskRequest indicates an expected call of CancelBundleTaskRequest.
func (mr *MockEC2APIMockRecorder) CancelBundleTaskRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTaskRequest), arg0)
}

// CancelBundleTaskWithContext mocks base method.
func (m *MockEC2API) CancelBundleTaskWithContext(arg0 context.Context, arg1 *ec2.CancelBundleTaskInput, arg2 ...request.Option) (*ec2.CancelBundleTaskOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelBundleTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelCapacityReservation mocks base method.
func (m *MockEC2API) CancelCapacityReservation(arg0 *ec2.CancelCapacityReservationInput) (*ec2.CancelCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelCapacityReservation", arg0)
	ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelCapacityReservation indicates an expected call of CancelCapacityReservation.
func (mr *MockEC2APIMockRecorder) CancelCapacityReservation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservation), arg0)
}

// CancelCapacityReservationFleets mocks base method.
func (m *MockEC2API) CancelCapacityReservationFleets(arg0 *ec2.CancelCapacityReservationFleetsInput) (*ec2.CancelCapacityReservationFleetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelCapacityReservationFleets", arg0)
	ret0, _ := ret[0].(*ec2.CancelCapacityReservationFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelCapacityReservationFleets indicates an expected call of CancelCapacityReservationFleets.
func (mr *MockEC2APIMockRecorder) CancelCapacityReservationFleets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationFleets", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationFleets), arg0)
}

// CancelCapacityReservationFleetsRequest mocks base method.
func (m *MockEC2API) CancelCapacityReservationFleetsRequest(arg0 *ec2.CancelCapacityReservationFleetsInput) (*request.Request, *ec2.CancelCapacityReservationFleetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelCapacityReservationFleetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelCapacityReservationFleetsOutput)
	return ret0, ret1
}

// CancelCapacityReservationFleetsRequest indicates an expected call of CancelCapacityReservationFleetsRequest.
func (mr *MockEC2APIMockRecorder) CancelCapacityReservationFleetsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationFleetsRequest), arg0)
}

// CancelCapacityReservationFleetsWithContext mocks base method.
func (m *MockEC2API) CancelCapacityReservationFleetsWithContext(arg0 context.Context, arg1 *ec2.CancelCapacityReservationFleetsInput, arg2 ...request.Option) (*ec2.CancelCapacityReservationFleetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelCapacityReservationFleetsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelCapacityReservationFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelCapacityReservationRequest mocks base method.
func (m *MockEC2API) CancelCapacityReservationRequest(arg0 *ec2.CancelCapacityReservationInput) (*request.Request, *ec2.CancelCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelCapacityReservationOutput)
	return ret0, ret1
}

// CancelCapacityReservationRequest indicates an expected call of CancelCapacityReservationRequest.
func (mr *MockEC2APIMockRecorder) CancelCapacityReservationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationRequest), arg0)
}

// CancelCapacityReservationWithContext mocks base method.
func (m *MockEC2API) CancelCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.CancelCapacityReservationInput, arg2 ...request.Option) (*ec2.CancelCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelConversionTask mocks base method.
func (m *MockEC2API) CancelConversionTask(arg0 *ec2.CancelConversionTaskInput) (*ec2.CancelConversionTaskOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelConversionTask", arg0)
	ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelConversionTask indicates an expected call of CancelConversionTask.
func (mr *MockEC2APIMockRecorder) CancelConversionTask(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTask", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTask), arg0)
}

// CancelConversionTaskRequest mocks base method.
func (m *MockEC2API) CancelConversionTaskRequest(arg0 *ec2.CancelConversionTaskInput) (*request.Request, *ec2.CancelConversionTaskOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelConversionTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelConversionTaskOutput)
	return ret0, ret1
}

// CancelConversionTaskRequest indicates an expected call of CancelConversionTaskRequest.
func (mr *MockEC2APIMockRecorder) CancelConversionTaskRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTaskRequest), arg0)
}

// CancelConversionTaskWithContext mocks base method.
func (m *MockEC2API) CancelConversionTaskWithContext(arg0 context.Context, arg1 *ec2.CancelConversionTaskInput, arg2 ...request.Option) (*ec2.CancelConversionTaskOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelConversionTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelExportTask mocks base method.
func (m *MockEC2API) CancelExportTask(arg0 *ec2.CancelExportTaskInput) (*ec2.CancelExportTaskOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelExportTask", arg0)
	ret0, _ := ret[0].(*ec2.CancelExportTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelExportTask indicates an expected call of CancelExportTask.
func (mr *MockEC2APIMockRecorder) CancelExportTask(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTask", reflect.TypeOf((*MockEC2API)(nil).CancelExportTask), arg0)
}

// CancelExportTaskRequest mocks base method.
func (m *MockEC2API) CancelExportTaskRequest(arg0 *ec2.CancelExportTaskInput) (*request.Request, *ec2.CancelExportTaskOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelExportTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelExportTaskOutput)
	return ret0, ret1
}

// CancelExportTaskRequest indicates an expected call of CancelExportTaskRequest.
func (mr *MockEC2APIMockRecorder) CancelExportTaskRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelExportTaskRequest), arg0)
}

// CancelExportTaskWithContext mocks base method.
func (m *MockEC2API) CancelExportTaskWithContext(arg0 context.Context, arg1 *ec2.CancelExportTaskInput, arg2 ...request.Option) (*ec2.CancelExportTaskOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelExportTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelExportTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelImageLaunchPermission mocks base method.
func (m *MockEC2API) CancelImageLaunchPermission(arg0 *ec2.CancelImageLaunchPermissionInput) (*ec2.CancelImageLaunchPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelImageLaunchPermission", arg0)
	ret0, _ := ret[0].(*ec2.CancelImageLaunchPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelImageLaunchPermission indicates an expected call of CancelImageLaunchPermission.
func (mr *MockEC2APIMockRecorder) CancelImageLaunchPermission(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImageLaunchPermission", reflect.TypeOf((*MockEC2API)(nil).CancelImageLaunchPermission), arg0)
}

// CancelImageLaunchPermissionRequest mocks base method.
func (m *MockEC2API) CancelImageLaunchPermissionRequest(arg0 *ec2.CancelImageLaunchPermissionInput) (*request.Request, *ec2.CancelImageLaunchPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelImageLaunchPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelImageLaunchPermissionOutput)
	return ret0, ret1
}

// CancelImageLaunchPermissionRequest indicates an expected call of CancelImageLaunchPermissionRequest.
func (mr *MockEC2APIMockRecorder) CancelImageLaunchPermissionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImageLaunchPermissionRequest", reflect.TypeOf((*MockEC2API)(nil).CancelImageLaunchPermissionRequest), arg0)
}

// CancelImageLaunchPermissionWithContext mocks base method.
func (m *MockEC2API) CancelImageLaunchPermissionWithContext(arg0 context.Context, arg1 *ec2.CancelImageLaunchPermissionInput, arg2 ...request.Option) (*ec2.CancelImageLaunchPermissionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelImageLaunchPermissionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelImageLaunchPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelImportTask mocks base method.
func (m *MockEC2API) CancelImportTask(arg0 *ec2.CancelImportTaskInput) (*ec2.CancelImportTaskOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelImportTask", arg0)
	ret0, _ := ret[0].(*ec2.CancelImportTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelImportTask indicates an expected call of CancelImportTask.
func (mr *MockEC2APIMockRecorder) CancelImportTask(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTask", reflect.TypeOf((*MockEC2API)(nil).CancelImportTask), arg0)
}

// CancelImportTaskRequest mocks base method.
func (m *MockEC2API) CancelImportTaskRequest(arg0 *ec2.CancelImportTaskInput) (*request.Request, *ec2.CancelImportTaskOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelImportTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelImportTaskOutput)
	return ret0, ret1
}

// CancelImportTaskRequest indicates an expected call of CancelImportTaskRequest.
func (mr *MockEC2APIMockRecorder) CancelImportTaskRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelImportTaskRequest), arg0)
}

// CancelImportTaskWithContext mocks base method.
func (m *MockEC2API) CancelImportTaskWithContext(arg0 context.Context, arg1 *ec2.CancelImportTaskInput, arg2 ...request.Option) (*ec2.CancelImportTaskOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelImportTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelImportTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelReservedInstancesListing mocks base method.
func (m *MockEC2API) CancelReservedInstancesListing(arg0 *ec2.CancelReservedInstancesListingInput) (*ec2.CancelReservedInstancesListingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelReservedInstancesListing", arg0)
	ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelReservedInstancesListing indicates an expected call of CancelReservedInstancesListing.
func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListing(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListing), arg0)
}

// CancelReservedInstancesListingRequest mocks base method.
func (m *MockEC2API) CancelReservedInstancesListingRequest(arg0 *ec2.CancelReservedInstancesListingInput) (*request.Request, *ec2.CancelReservedInstancesListingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelReservedInstancesListingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelReservedInstancesListingOutput)
	return ret0, ret1
}

// CancelReservedInstancesListingRequest indicates an expected call of CancelReservedInstancesListingRequest.
func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListingRequest), arg0)
}

// CancelReservedInstancesListingWithContext mocks base method.
func (m *MockEC2API) CancelReservedInstancesListingWithContext(arg0 context.Context, arg1 *ec2.CancelReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CancelReservedInstancesListingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelReservedInstancesListingWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelSpotFleetRequests mocks base method.
func (m *MockEC2API) CancelSpotFleetRequests(arg0 *ec2.CancelSpotFleetRequestsInput) (*ec2.CancelSpotFleetRequestsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelSpotFleetRequests", arg0)
	ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelSpotFleetRequests indicates an expected call of CancelSpotFleetRequests.
func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequests(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequests), arg0)
}

// CancelSpotFleetRequestsRequest mocks base method.
func (m *MockEC2API) CancelSpotFleetRequestsRequest(arg0 *ec2.CancelSpotFleetRequestsInput) (*request.Request, *ec2.CancelSpotFleetRequestsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelSpotFleetRequestsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelSpotFleetRequestsOutput)
	return ret0, ret1
}

// CancelSpotFleetRequestsRequest indicates an expected call of CancelSpotFleetRequestsRequest.
func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequestsRequest), arg0)
}

// CancelSpotFleetRequestsWithContext mocks base method.
func (m *MockEC2API) CancelSpotFleetRequestsWithContext(arg0 context.Context, arg1 *ec2.CancelSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotFleetRequestsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelSpotFleetRequestsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelSpotInstanceRequests mocks base method.
func (m *MockEC2API) CancelSpotInstanceRequests(arg0 *ec2.CancelSpotInstanceRequestsInput) (*ec2.CancelSpotInstanceRequestsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelSpotInstanceRequests", arg0)
	ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelSpotInstanceRequests indicates an expected call of CancelSpotInstanceRequests.
func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequests(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequests), arg0)
}

// CancelSpotInstanceRequestsRequest mocks base method.
func (m *MockEC2API) CancelSpotInstanceRequestsRequest(arg0 *ec2.CancelSpotInstanceRequestsInput) (*request.Request, *ec2.CancelSpotInstanceRequestsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CancelSpotInstanceRequestsOutput)
	return ret0, ret1
}

// CancelSpotInstanceRequestsRequest indicates an expected call of CancelSpotInstanceRequestsRequest.
func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequestsRequest), arg0)
}

// CancelSpotInstanceRequestsWithContext mocks base method.
func (m *MockEC2API) CancelSpotInstanceRequestsWithContext(arg0 context.Context, arg1 *ec2.CancelSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotInstanceRequestsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ConfirmProductInstance mocks base method.
func (m *MockEC2API) ConfirmProductInstance(arg0 *ec2.ConfirmProductInstanceInput) (*ec2.ConfirmProductInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfirmProductInstance", arg0)
	ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConfirmProductInstance indicates an expected call of ConfirmProductInstance.
func (mr *MockEC2APIMockRecorder) ConfirmProductInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstance", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstance), arg0)
}

// ConfirmProductInstanceRequest mocks base method.
func (m *MockEC2API) ConfirmProductInstanceRequest(arg0 *ec2.ConfirmProductInstanceInput) (*request.Request, *ec2.ConfirmProductInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfirmProductInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ConfirmProductInstanceOutput)
	return ret0, ret1
}

// ConfirmProductInstanceRequest indicates an expected call of ConfirmProductInstanceRequest.
func (mr *MockEC2APIMockRecorder) ConfirmProductInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstanceRequest), arg0)
}

// ConfirmProductInstanceWithContext mocks base method.
func (m *MockEC2API) ConfirmProductInstanceWithContext(arg0 context.Context, arg1 *ec2.ConfirmProductInstanceInput, arg2 ...request.Option) (*ec2.ConfirmProductInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ConfirmProductInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CopyFpgaImage mocks base method.
func (m *MockEC2API) CopyFpgaImage(arg0 *ec2.CopyFpgaImageInput) (*ec2.CopyFpgaImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyFpgaImage", arg0)
	ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyFpgaImage indicates an expected call of CopyFpgaImage.
func (mr *MockEC2APIMockRecorder) CopyFpgaImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImage), arg0)
}

// CopyFpgaImageRequest mocks base method.
func (m *MockEC2API) CopyFpgaImageRequest(arg0 *ec2.CopyFpgaImageInput) (*request.Request, *ec2.CopyFpgaImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyFpgaImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CopyFpgaImageOutput)
	return ret0, ret1
}

// CopyFpgaImageRequest indicates an expected call of CopyFpgaImageRequest.
func (mr *MockEC2APIMockRecorder) CopyFpgaImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImageRequest), arg0)
}

// CopyFpgaImageWithContext mocks base method.
func (m *MockEC2API) CopyFpgaImageWithContext(arg0 context.Context, arg1 *ec2.CopyFpgaImageInput, arg2 ...request.Option) (*ec2.CopyFpgaImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CopyFpgaImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CopyImage mocks base method.
func (m *MockEC2API) CopyImage(arg0 *ec2.CopyImageInput) (*ec2.CopyImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyImage", arg0)
	ret0, _ := ret[0].(*ec2.CopyImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyImage indicates an expected call of CopyImage.
func (mr *MockEC2APIMockRecorder) CopyImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImage", reflect.TypeOf((*MockEC2API)(nil).CopyImage), arg0)
}

// CopyImageRequest mocks base method.
func (m *MockEC2API) CopyImageRequest(arg0 *ec2.CopyImageInput) (*request.Request, *ec2.CopyImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CopyImageOutput)
	return ret0, ret1
}

// CopyImageRequest indicates an expected call of CopyImageRequest.
func (mr *MockEC2APIMockRecorder) CopyImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyImageRequest), arg0)
}

// CopyImageWithContext mocks base method.
func (m *MockEC2API) CopyImageWithContext(arg0 context.Context, arg1 *ec2.CopyImageInput, arg2 ...request.Option) (*ec2.CopyImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CopyImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CopyImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CopySnapshot mocks base method.
func (m *MockEC2API) CopySnapshot(arg0 *ec2.CopySnapshotInput) (*ec2.CopySnapshotOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopySnapshot", arg0)
	ret0, _ := ret[0].(*ec2.CopySnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopySnapshot indicates an expected call of CopySnapshot.
func (mr *MockEC2APIMockRecorder) CopySnapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshot", reflect.TypeOf((*MockEC2API)(nil).CopySnapshot), arg0)
}

// CopySnapshotRequest mocks base method.
func (m *MockEC2API) CopySnapshotRequest(arg0 *ec2.CopySnapshotInput) (*request.Request, *ec2.CopySnapshotOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopySnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CopySnapshotOutput)
	return ret0, ret1
}

// CopySnapshotRequest indicates an expected call of CopySnapshotRequest.
func (mr *MockEC2APIMockRecorder) CopySnapshotRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CopySnapshotRequest), arg0)
}

// CopySnapshotWithContext mocks base method.
func (m *MockEC2API) CopySnapshotWithContext(arg0 context.Context, arg1 *ec2.CopySnapshotInput, arg2 ...request.Option) (*ec2.CopySnapshotOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CopySnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CopySnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCapacityReservation mocks base method.
func (m *MockEC2API) CreateCapacityReservation(arg0 *ec2.CreateCapacityReservationInput) (*ec2.CreateCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCapacityReservation", arg0)
	ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCapacityReservation indicates an expected call of CreateCapacityReservation.
func (mr *MockEC2APIMockRecorder) CreateCapacityReservation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservation), arg0)
}

// CreateCapacityReservationFleet mocks base method.
func (m *MockEC2API) CreateCapacityReservationFleet(arg0 *ec2.CreateCapacityReservationFleetInput) (*ec2.CreateCapacityReservationFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCapacityReservationFleet", arg0)
	ret0, _ := ret[0].(*ec2.CreateCapacityReservationFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCapacityReservationFleet indicates an expected call of CreateCapacityReservationFleet.
func (mr *MockEC2APIMockRecorder) CreateCapacityReservationFleet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationFleet", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationFleet), arg0)
}

// CreateCapacityReservationFleetRequest mocks base method.
func (m *MockEC2API) CreateCapacityReservationFleetRequest(arg0 *ec2.CreateCapacityReservationFleetInput) (*request.Request, *ec2.CreateCapacityReservationFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCapacityReservationFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateCapacityReservationFleetOutput)
	return ret0, ret1
}

// CreateCapacityReservationFleetRequest indicates an expected call of CreateCapacityReservationFleetRequest.
func (mr *MockEC2APIMockRecorder) CreateCapacityReservationFleetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationFleetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationFleetRequest), arg0)
}

// CreateCapacityReservationFleetWithContext mocks base method.
func (m *MockEC2API) CreateCapacityReservationFleetWithContext(arg0 context.Context, arg1 *ec2.CreateCapacityReservationFleetInput, arg2 ...request.Option) (*ec2.CreateCapacityReservationFleetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCapacityReservationFleetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateCapacityReservationFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCapacityReservationRequest mocks base method.
func (m *MockEC2API) CreateCapacityReservationRequest(arg0 *ec2.CreateCapacityReservationInput) (*request.Request, *ec2.CreateCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateCapacityReservationOutput)
	return ret0, ret1
}

// CreateCapacityReservationRequest indicates an expected call of CreateCapacityReservationRequest.
func (mr *MockEC2APIMockRecorder) CreateCapacityReservationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationRequest), arg0)
}

// CreateCapacityReservationWithContext mocks base method.
func (m *MockEC2API) CreateCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.CreateCapacityReservationInput, arg2 ...request.Option) (*ec2.CreateCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCarrierGateway mocks base method.
func (m *MockEC2API) CreateCarrierGateway(arg0 *ec2.CreateCarrierGatewayInput) (*ec2.CreateCarrierGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCarrierGateway", arg0)
	ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCarrierGateway indicates an expected call of CreateCarrierGateway.
func (mr *MockEC2APIMockRecorder) CreateCarrierGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGateway), arg0)
}

// CreateCarrierGatewayRequest mocks base method.
func (m *MockEC2API) CreateCarrierGatewayRequest(arg0 *ec2.CreateCarrierGatewayInput) (*request.Request, *ec2.CreateCarrierGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCarrierGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateCarrierGatewayOutput)
	return ret0, ret1
}

// CreateCarrierGatewayRequest indicates an expected call of CreateCarrierGatewayRequest.
func (mr *MockEC2APIMockRecorder) CreateCarrierGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGatewayRequest), arg0)
}

// CreateCarrierGatewayWithContext mocks base method.
func (m *MockEC2API) CreateCarrierGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateCarrierGatewayInput, arg2 ...request.Option) (*ec2.CreateCarrierGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCarrierGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateClientVpnEndpoint mocks base method.
func (m *MockEC2API) CreateClientVpnEndpoint(arg0 *ec2.CreateClientVpnEndpointInput) (*ec2.CreateClientVpnEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClientVpnEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateClientVpnEndpoint indicates an expected call of CreateClientVpnEndpoint.
func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpoint), arg0)
}

// CreateClientVpnEndpointRequest mocks base method.
func (m *MockEC2API) CreateClientVpnEndpointRequest(arg0 *ec2.CreateClientVpnEndpointInput) (*request.Request, *ec2.CreateClientVpnEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClientVpnEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateClientVpnEndpointOutput)
	return ret0, ret1
}

// CreateClientVpnEndpointRequest indicates an expected call of CreateClientVpnEndpointRequest.
func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpointRequest), arg0)
}

// CreateClientVpnEndpointWithContext mocks base method.
func (m *MockEC2API) CreateClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateClientVpnEndpointInput, arg2 ...request.Option) (*ec2.CreateClientVpnEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateClientVpnEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateClientVpnRoute mocks base method.
func (m *MockEC2API) CreateClientVpnRoute(arg0 *ec2.CreateClientVpnRouteInput) (*ec2.CreateClientVpnRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClientVpnRoute", arg0)
	ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateClientVpnRoute indicates an expected call of CreateClientVpnRoute.
func (mr *MockEC2APIMockRecorder) CreateClientVpnRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRoute), arg0)
}

// CreateClientVpnRouteRequest mocks base method.
func (m *MockEC2API) CreateClientVpnRouteRequest(arg0 *ec2.CreateClientVpnRouteInput) (*request.Request, *ec2.CreateClientVpnRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClientVpnRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateClientVpnRouteOutput)
	return ret0, ret1
}

// CreateClientVpnRouteRequest indicates an expected call of CreateClientVpnRouteRequest.
func (mr *MockEC2APIMockRecorder) CreateClientVpnRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRouteRequest), arg0)
}

// CreateClientVpnRouteWithContext mocks base method.
func (m *MockEC2API) CreateClientVpnRouteWithContext(arg0 context.Context, arg1 *ec2.CreateClientVpnRouteInput, arg2 ...request.Option) (*ec2.CreateClientVpnRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateClientVpnRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCoipCidr mocks base method.
func (m *MockEC2API) CreateCoipCidr(arg0 *ec2.CreateCoipCidrInput) (*ec2.CreateCoipCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCoipCidr", arg0)
	ret0, _ := ret[0].(*ec2.CreateCoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCoipCidr indicates an expected call of CreateCoipCidr.
func (mr *MockEC2APIMockRecorder) CreateCoipCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipCidr", reflect.TypeOf((*MockEC2API)(nil).CreateCoipCidr), arg0)
}

// CreateCoipCidrRequest mocks base method.
func (m *MockEC2API) CreateCoipCidrRequest(arg0 *ec2.CreateCoipCidrInput) (*request.Request, *ec2.CreateCoipCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCoipCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateCoipCidrOutput)
	return ret0, ret1
}

// CreateCoipCidrRequest indicates an expected call of CreateCoipCidrRequest.
func (mr *MockEC2APIMockRecorder) CreateCoipCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCoipCidrRequest), arg0)
}

// CreateCoipCidrWithContext mocks base method.
func (m *MockEC2API) CreateCoipCidrWithContext(arg0 context.Context, arg1 *ec2.CreateCoipCidrInput, arg2 ...request.Option) (*ec2.CreateCoipCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCoipCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateCoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCoipPool mocks base method.
func (m *MockEC2API) CreateCoipPool(arg0 *ec2.CreateCoipPoolInput) (*ec2.CreateCoipPoolOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCoipPool", arg0)
	ret0, _ := ret[0].(*ec2.CreateCoipPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCoipPool indicates an expected call of CreateCoipPool.
func (mr *MockEC2APIMockRecorder) CreateCoipPool(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipPool", reflect.TypeOf((*MockEC2API)(nil).CreateCoipPool), arg0)
}

// CreateCoipPoolRequest mocks base method.
func (m *MockEC2API) CreateCoipPoolRequest(arg0 *ec2.CreateCoipPoolInput) (*request.Request, *ec2.CreateCoipPoolOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCoipPoolRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateCoipPoolOutput)
	return ret0, ret1
}

// CreateCoipPoolRequest indicates an expected call of CreateCoipPoolRequest.
func (mr *MockEC2APIMockRecorder) CreateCoipPoolRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipPoolRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCoipPoolRequest), arg0)
}

// CreateCoipPoolWithContext mocks base method.
func (m *MockEC2API) CreateCoipPoolWithContext(arg0 context.Context, arg1 *ec2.CreateCoipPoolInput, arg2 ...request.Option) (*ec2.CreateCoipPoolOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCoipPoolWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateCoipPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCustomerGateway mocks base method.
func (m *MockEC2API) CreateCustomerGateway(arg0 *ec2.CreateCustomerGatewayInput) (*ec2.CreateCustomerGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCustomerGateway", arg0)
	ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCustomerGateway indicates an expected call of CreateCustomerGateway.
func (mr *MockEC2APIMockRecorder) CreateCustomerGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGateway), arg0)
}

// CreateCustomerGatewayRequest mocks base method.
func (m *MockEC2API) CreateCustomerGatewayRequest(arg0 *ec2.CreateCustomerGatewayInput) (*request.Request, *ec2.CreateCustomerGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCustomerGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateCustomerGatewayOutput)
	return ret0, ret1
}

// CreateCustomerGatewayRequest indicates an expected call of CreateCustomerGatewayRequest.
func (mr *MockEC2APIMockRecorder) CreateCustomerGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGatewayRequest), arg0)
}

// CreateCustomerGatewayWithContext mocks base method.
func (m *MockEC2API) CreateCustomerGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateCustomerGatewayInput, arg2 ...request.Option) (*ec2.CreateCustomerGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCustomerGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDefaultSubnet mocks base method.
func (m *MockEC2API) CreateDefaultSubnet(arg0 *ec2.CreateDefaultSubnetInput) (*ec2.CreateDefaultSubnetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDefaultSubnet", arg0)
	ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDefaultSubnet indicates an expected call of CreateDefaultSubnet.
func (mr *MockEC2APIMockRecorder) CreateDefaultSubnet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnet), arg0)
}

// CreateDefaultSubnetRequest mocks base method.
func (m *MockEC2API) CreateDefaultSubnetRequest(arg0 *ec2.CreateDefaultSubnetInput) (*request.Request, *ec2.CreateDefaultSubnetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDefaultSubnetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateDefaultSubnetOutput)
	return ret0, ret1
}

// CreateDefaultSubnetRequest indicates an expected call of CreateDefaultSubnetRequest.
func (mr *MockEC2APIMockRecorder) CreateDefaultSubnetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnetRequest), arg0)
}

// CreateDefaultSubnetWithContext mocks base method.
func (m *MockEC2API) CreateDefaultSubnetWithContext(arg0 context.Context, arg1 *ec2.CreateDefaultSubnetInput, arg2 ...request.Option) (*ec2.CreateDefaultSubnetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateDefaultSubnetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDefaultVpc mocks base method.
func (m *MockEC2API) CreateDefaultVpc(arg0 *ec2.CreateDefaultVpcInput) (*ec2.CreateDefaultVpcOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDefaultVpc", arg0)
	ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDefaultVpc indicates an expected call of CreateDefaultVpc.
func (mr *MockEC2APIMockRecorder) CreateDefaultVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpc", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpc), arg0)
}

// CreateDefaultVpcRequest mocks base method.
func (m *MockEC2API) CreateDefaultVpcRequest(arg0 *ec2.CreateDefaultVpcInput) (*request.Request, *ec2.CreateDefaultVpcOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDefaultVpcRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateDefaultVpcOutput)
	return ret0, ret1
}

// CreateDefaultVpcRequest indicates an expected call of CreateDefaultVpcRequest.
func (mr *MockEC2APIMockRecorder) CreateDefaultVpcRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpcRequest), arg0)
}

// CreateDefaultVpcWithContext mocks base method.
func (m *MockEC2API) CreateDefaultVpcWithContext(arg0 context.Context, arg1 *ec2.CreateDefaultVpcInput, arg2 ...request.Option) (*ec2.CreateDefaultVpcOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateDefaultVpcWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDhcpOptions mocks base method.
func (m *MockEC2API) CreateDhcpOptions(arg0 *ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDhcpOptions", arg0)
	ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDhcpOptions indicates an expected call of CreateDhcpOptions.
func (mr *MockEC2APIMockRecorder) CreateDhcpOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptions), arg0)
}

// CreateDhcpOptionsRequest mocks base method.
func (m *MockEC2API) CreateDhcpOptionsRequest(arg0 *ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDhcpOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateDhcpOptionsOutput)
	return ret0, ret1
}

// CreateDhcpOptionsRequest indicates an expected call of CreateDhcpOptionsRequest.
func (mr *MockEC2APIMockRecorder) CreateDhcpOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptionsRequest), arg0)
}

// CreateDhcpOptionsWithContext mocks base method.
func (m *MockEC2API) CreateDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.CreateDhcpOptionsInput, arg2 ...request.Option) (*ec2.CreateDhcpOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateDhcpOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEgressOnlyInternetGateway mocks base method.
func (m *MockEC2API) CreateEgressOnlyInternetGateway(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGateway", arg0)
	ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateEgressOnlyInternetGateway indicates an expected call of CreateEgressOnlyInternetGateway.
func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGateway), arg0)
}

// CreateEgressOnlyInternetGatewayRequest mocks base method.
func (m *MockEC2API) CreateEgressOnlyInternetGatewayRequest(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*request.Request, *ec2.CreateEgressOnlyInternetGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateEgressOnlyInternetGatewayOutput)
	return ret0, ret1
}

// CreateEgressOnlyInternetGatewayRequest indicates an expected call of CreateEgressOnlyInternetGatewayRequest.
func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayRequest), arg0)
}

// CreateEgressOnlyInternetGatewayWithContext mocks base method.
func (m *MockEC2API) CreateEgressOnlyInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFleet mocks base method.
func (m *MockEC2API) CreateFleet(arg0 *ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFleet", arg0)
	ret0, _ := ret[0].(*ec2.CreateFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFleet indicates an expected call of CreateFleet.
func (mr *MockEC2APIMockRecorder) CreateFleet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleet", reflect.TypeOf((*MockEC2API)(nil).CreateFleet), arg0)
}

// CreateFleetRequest mocks base method.
func (m *MockEC2API) CreateFleetRequest(arg0 *ec2.CreateFleetInput) (*request.Request, *ec2.CreateFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateFleetOutput)
	return ret0, ret1
}

// CreateFleetRequest indicates an expected call of CreateFleetRequest.
func (mr *MockEC2APIMockRecorder) CreateFleetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFleetRequest), arg0)
}

// CreateFleetWithContext mocks base method.
func (m *MockEC2API) CreateFleetWithContext(arg0 context.Context, arg1 *ec2.CreateFleetInput, arg2 ...request.Option) (*ec2.CreateFleetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFleetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFlowLogs mocks base method.
func (m *MockEC2API) CreateFlowLogs(arg0 *ec2.CreateFlowLogsInput) (*ec2.CreateFlowLogsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFlowLogs", arg0)
	ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFlowLogs indicates an expected call of CreateFlowLogs.
func (mr *MockEC2APIMockRecorder) CreateFlowLogs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogs", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogs), arg0)
}

// CreateFlowLogsRequest mocks base method.
func (m *MockEC2API) CreateFlowLogsRequest(arg0 *ec2.CreateFlowLogsInput) (*request.Request, *ec2.CreateFlowLogsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFlowLogsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateFlowLogsOutput)
	return ret0, ret1
}

// CreateFlowLogsRequest indicates an expected call of CreateFlowLogsRequest.
func (mr *MockEC2APIMockRecorder) CreateFlowLogsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogsRequest), arg0)
}

// CreateFlowLogsWithContext mocks base method.
func (m *MockEC2API) CreateFlowLogsWithContext(arg0 context.Context, arg1 *ec2.CreateFlowLogsInput, arg2 ...request.Option) (*ec2.CreateFlowLogsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFlowLogsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFpgaImage mocks base method.
func (m *MockEC2API) CreateFpgaImage(arg0 *ec2.CreateFpgaImageInput) (*ec2.CreateFpgaImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFpgaImage", arg0)
	ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFpgaImage indicates an expected call of CreateFpgaImage.
func (mr *MockEC2APIMockRecorder) CreateFpgaImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImage), arg0)
}

// CreateFpgaImageRequest mocks base method.
func (m *MockEC2API) CreateFpgaImageRequest(arg0 *ec2.CreateFpgaImageInput) (*request.Request, *ec2.CreateFpgaImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFpgaImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateFpgaImageOutput)
	return ret0, ret1
}

// CreateFpgaImageRequest indicates an expected call of CreateFpgaImageRequest.
func (mr *MockEC2APIMockRecorder) CreateFpgaImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImageRequest), arg0)
}

// CreateFpgaImageWithContext mocks base method.
func (m *MockEC2API) CreateFpgaImageWithContext(arg0 context.Context, arg1 *ec2.CreateFpgaImageInput, arg2 ...request.Option) (*ec2.CreateFpgaImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFpgaImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateImage mocks base method.
func (m *MockEC2API) CreateImage(arg0 *ec2.CreateImageInput) (*ec2.CreateImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImage", arg0)
	ret0, _ := ret[0].(*ec2.CreateImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateImage indicates an expected call of CreateImage.
func (mr *MockEC2APIMockRecorder) CreateImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockEC2API)(nil).CreateImage), arg0)
}

// CreateImageRequest mocks base method.
func (m *MockEC2API) CreateImageRequest(arg0 *ec2.CreateImageInput) (*request.Request, *ec2.CreateImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateImageOutput)
	return ret0, ret1
}

// CreateImageRequest indicates an expected call of CreateImageRequest.
func (mr *MockEC2APIMockRecorder) CreateImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateImageRequest), arg0)
}

// CreateImageWithContext mocks base method.
func (m *MockEC2API) CreateImageWithContext(arg0 context.Context, arg1 *ec2.CreateImageInput, arg2 ...request.Option) (*ec2.CreateImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInstanceConnectEndpoint mocks base method.
func (m *MockEC2API) CreateInstanceConnectEndpoint(arg0 *ec2.CreateInstanceConnectEndpointInput) (*ec2.CreateInstanceConnectEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstanceConnectEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.CreateInstanceConnectEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateInstanceConnectEndpoint indicates an expected call of CreateInstanceConnectEndpoint.
func (mr *MockEC2APIMockRecorder) CreateInstanceConnectEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceConnectEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceConnectEndpoint), arg0)
}

// CreateInstanceConnectEndpointRequest mocks base method.
func (m *MockEC2API) CreateInstanceConnectEndpointRequest(arg0 *ec2.CreateInstanceConnectEndpointInput) (*request.Request, *ec2.CreateInstanceConnectEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstanceConnectEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateInstanceConnectEndpointOutput)
	return ret0, ret1
}

// CreateInstanceConnectEndpointRequest indicates an expected call of CreateInstanceConnectEndpointRequest.
func (mr *MockEC2APIMockRecorder) CreateInstanceConnectEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceConnectEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceConnectEndpointRequest), arg0)
}

// CreateInstanceConnectEndpointWithContext mocks base method.
func (m *MockEC2API) CreateInstanceConnectEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceConnectEndpointInput, arg2 ...request.Option) (*ec2.CreateInstanceConnectEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateInstanceConnectEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateInstanceConnectEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInstanceEventWindow mocks base method.
func (m *MockEC2API) CreateInstanceEventWindow(arg0 *ec2.CreateInstanceEventWindowInput) (*ec2.CreateInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstanceEventWindow", arg0)
	ret0, _ := ret[0].(*ec2.CreateInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateInstanceEventWindow indicates an expected call of CreateInstanceEventWindow.
func (mr *MockEC2APIMockRecorder) CreateInstanceEventWindow(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceEventWindow), arg0)
}

// CreateInstanceEventWindowRequest mocks base method.
func (m *MockEC2API) CreateInstanceEventWindowRequest(arg0 *ec2.CreateInstanceEventWindowInput) (*request.Request, *ec2.CreateInstanceEventWindowOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstanceEventWindowRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateInstanceEventWindowOutput)
	return ret0, ret1
}

// CreateInstanceEventWindowRequest indicates an expected call of CreateInstanceEventWindowRequest.
func (mr *MockEC2APIMockRecorder) CreateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceEventWindowRequest), arg0)
}

// CreateInstanceEventWindowWithContext mocks base method.
func (m *MockEC2API) CreateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.CreateInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateInstanceEventWindowWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInstanceExportTask mocks base method.
func (m *MockEC2API) CreateInstanceExportTask(arg0 *ec2.CreateInstanceExportTaskInput) (*ec2.CreateInstanceExportTaskOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstanceExportTask", arg0)
	ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateInstanceExportTask indicates an expected call of CreateInstanceExportTask.
func (mr *MockEC2APIMockRecorder) CreateInstanceExportTask(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTask", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTask), arg0)
}

// CreateInstanceExportTaskRequest mocks base method.
func (m *MockEC2API) CreateInstanceExportTaskRequest(arg0 *ec2.CreateInstanceExportTaskInput) (*request.Request, *ec2.CreateInstanceExportTaskOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstanceExportTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateInstanceExportTaskOutput)
	return ret0, ret1
}

// CreateInstanceExportTaskRequest indicates an expected call of CreateInstanceExportTaskRequest.
func (mr *MockEC2APIMockRecorder) CreateInstanceExportTaskRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTaskRequest), arg0)
}

// CreateInstanceExportTaskWithContext mocks base method.
func (m *MockEC2API) CreateInstanceExportTaskWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceExportTaskInput, arg2 ...request.Option) (*ec2.CreateInstanceExportTaskOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateInstanceExportTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInternetGateway mocks base method.
func (m *MockEC2API) CreateInternetGateway(arg0 *ec2.CreateInternetGatewayInput) (*ec2.CreateInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInternetGateway", arg0)
	ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateInternetGateway indicates an expected call of CreateInternetGateway.
func (mr *MockEC2APIMockRecorder) CreateInternetGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGateway), arg0)
}

// CreateInternetGatewayRequest mocks base method.
func (m *MockEC2API) CreateInternetGatewayRequest(arg0 *ec2.CreateInternetGatewayInput) (*request.Request, *ec2.CreateInternetGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInternetGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateInternetGatewayOutput)
	return ret0, ret1
}

// CreateInternetGatewayRequest indicates an expected call of CreateInternetGatewayRequest.
func (mr *MockEC2APIMockRecorder) CreateInternetGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGatewayRequest), arg0)
}

// CreateInternetGatewayWithContext mocks base method.
func (m *MockEC2API) CreateInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateInternetGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIpam mocks base method.
func (m *MockEC2API) CreateIpam(arg0 *ec2.CreateIpamInput) (*ec2.CreateIpamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpam", arg0)
	ret0, _ := ret[0].(*ec2.CreateIpamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIpam indicates an expected call of CreateIpam.
func (mr *MockEC2APIMockRecorder) CreateIpam(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpam", reflect.TypeOf((*MockEC2API)(nil).CreateIpam), arg0)
}

// CreateIpamExternalResourceVerificationToken mocks base method.
func (m *MockEC2API) CreateIpamExternalResourceVerificationToken(arg0 *ec2.CreateIpamExternalResourceVerificationTokenInput) (*ec2.CreateIpamExternalResourceVerificationTokenOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamExternalResourceVerificationToken", arg0)
	ret0, _ := ret[0].(*ec2.CreateIpamExternalResourceVerificationTokenOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIpamExternalResourceVerificationToken indicates an expected call of CreateIpamExternalResourceVerificationToken.
func (mr *MockEC2APIMockRecorder) CreateIpamExternalResourceVerificationToken(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamExternalResourceVerificationToken", reflect.TypeOf((*MockEC2API)(nil).CreateIpamExternalResourceVerificationToken), arg0)
}

// CreateIpamExternalResourceVerificationTokenRequest mocks base method.
func (m *MockEC2API) CreateIpamExternalResourceVerificationTokenRequest(arg0 *ec2.CreateIpamExternalResourceVerificationTokenInput) (*request.Request, *ec2.CreateIpamExternalResourceVerificationTokenOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamExternalResourceVerificationTokenRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateIpamExternalResourceVerificationTokenOutput)
	return ret0, ret1
}

// CreateIpamExternalResourceVerificationTokenRequest indicates an expected call of CreateIpamExternalResourceVerificationTokenRequest.
func (mr *MockEC2APIMockRecorder) CreateIpamExternalResourceVerificationTokenRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamExternalResourceVerificationTokenRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamExternalResourceVerificationTokenRequest), arg0)
}

// CreateIpamExternalResourceVerificationTokenWithContext mocks base method.
func (m *MockEC2API) CreateIpamExternalResourceVerificationTokenWithContext(arg0 context.Context, arg1 *ec2.CreateIpamExternalResourceVerificationTokenInput, arg2 ...request.Option) (*ec2.CreateIpamExternalResourceVerificationTokenOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateIpamExternalResourceVerificationTokenWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateIpamExternalResourceVerificationTokenOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIpamPool mocks base method.
func (m *MockEC2API) CreateIpamPool(arg0 *ec2.CreateIpamPoolInput) (*ec2.CreateIpamPoolOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamPool", arg0)
	ret0, _ := ret[0].(*ec2.CreateIpamPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIpamPool indicates an expected call of CreateIpamPool.
func (mr *MockEC2APIMockRecorder) CreateIpamPool(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamPool", reflect.TypeOf((*MockEC2API)(nil).CreateIpamPool), arg0)
}

// CreateIpamPoolRequest mocks base method.
func (m *MockEC2API) CreateIpamPoolRequest(arg0 *ec2.CreateIpamPoolInput) (*request.Request, *ec2.CreateIpamPoolOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamPoolRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateIpamPoolOutput)
	return ret0, ret1
}

// CreateIpamPoolRequest indicates an expected call of CreateIpamPoolRequest.
func (mr *MockEC2APIMockRecorder) CreateIpamPoolRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamPoolRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamPoolRequest), arg0)
}

// CreateIpamPoolWithContext mocks base method.
func (m *MockEC2API) CreateIpamPoolWithContext(arg0 context.Context, arg1 *ec2.CreateIpamPoolInput, arg2 ...request.Option) (*ec2.CreateIpamPoolOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateIpamPoolWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateIpamPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIpamRequest mocks base method.
func (m *MockEC2API) CreateIpamRequest(arg0 *ec2.CreateIpamInput) (*request.Request, *ec2.CreateIpamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateIpamOutput)
	return ret0, ret1
}

// CreateIpamRequest indicates an expected call of CreateIpamRequest.
func (mr *MockEC2APIMockRecorder) CreateIpamRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamRequest), arg0)
}

// CreateIpamResourceDiscovery mocks base method.
func (m *MockEC2API) CreateIpamResourceDiscovery(arg0 *ec2.CreateIpamResourceDiscoveryInput) (*ec2.CreateIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamResourceDiscovery", arg0)
	ret0, _ := ret[0].(*ec2.CreateIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIpamResourceDiscovery indicates an expected call of CreateIpamResourceDiscovery.
func (mr *MockEC2APIMockRecorder) CreateIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).CreateIpamResourceDiscovery), arg0)
}

// CreateIpamResourceDiscoveryRequest mocks base method.
func (m *MockEC2API) CreateIpamResourceDiscoveryRequest(arg0 *ec2.CreateIpamResourceDiscoveryInput) (*request.Request, *ec2.CreateIpamResourceDiscoveryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamResourceDiscoveryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateIpamResourceDiscoveryOutput)
	return ret0, ret1
}

// CreateIpamResourceDiscoveryRequest indicates an expected call of CreateIpamResourceDiscoveryRequest.
func (mr *MockEC2APIMockRecorder) CreateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamResourceDiscoveryRequest), arg0)
}

// CreateIpamResourceDiscoveryWithContext mocks base method.
func (m *MockEC2API) CreateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.CreateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.CreateIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateIpamResourceDiscoveryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIpamScope mocks base method.
func (m *MockEC2API) CreateIpamScope(arg0 *ec2.CreateIpamScopeInput) (*ec2.CreateIpamScopeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamScope", arg0)
	ret0, _ := ret[0].(*ec2.CreateIpamScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIpamScope indicates an expected call of CreateIpamScope.
func (mr *MockEC2APIMockRecorder) CreateIpamScope(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamScope", reflect.TypeOf((*MockEC2API)(nil).CreateIpamScope), arg0)
}

// CreateIpamScopeRequest mocks base method.
func (m *MockEC2API) CreateIpamScopeRequest(arg0 *ec2.CreateIpamScopeInput) (*request.Request, *ec2.CreateIpamScopeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIpamScopeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateIpamScopeOutput)
	return ret0, ret1
}

// CreateIpamScopeRequest indicates an expected call of CreateIpamScopeRequest.
func (mr *MockEC2APIMockRecorder) CreateIpamScopeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamScopeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateIpamScopeRequest), arg0)
}

// CreateIpamScopeWithContext mocks base method.
func (m *MockEC2API) CreateIpamScopeWithContext(arg0 context.Context, arg1 *ec2.CreateIpamScopeInput, arg2 ...request.Option) (*ec2.CreateIpamScopeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateIpamScopeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateIpamScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIpamWithContext mocks base method.
func (m *MockEC2API) CreateIpamWithContext(arg0 context.Context, arg1 *ec2.CreateIpamInput, arg2 ...request.Option) (*ec2.CreateIpamOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateIpamWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateIpamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateKeyPair mocks base method.
func (m *MockEC2API) CreateKeyPair(arg0 *ec2.CreateKeyPairInput) (*ec2.CreateKeyPairOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateKeyPair", arg0)
	ret0, _ := ret[0].(*ec2.CreateKeyPairOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateKeyPair indicates an expected call of CreateKeyPair.
func (mr *MockEC2APIMockRecorder) CreateKeyPair(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPair", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPair), arg0)
}

// CreateKeyPairRequest mocks base method.
func (m *MockEC2API) CreateKeyPairRequest(arg0 *ec2.CreateKeyPairInput) (*request.Request, *ec2.CreateKeyPairOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateKeyPairRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateKeyPairOutput)
	return ret0, ret1
}

// CreateKeyPairRequest indicates an expected call of CreateKeyPairRequest.
func (mr *MockEC2APIMockRecorder) CreateKeyPairRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPairRequest), arg0)
}

// CreateKeyPairWithContext mocks base method.
func (m *MockEC2API) CreateKeyPairWithContext(arg0 context.Context, arg1 *ec2.CreateKeyPairInput, arg2 ...request.Option) (*ec2.CreateKeyPairOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateKeyPairWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateKeyPairOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLaunchTemplate mocks base method.
func (m *MockEC2API) CreateLaunchTemplate(arg0 *ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLaunchTemplate", arg0)
	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLaunchTemplate indicates an expected call of CreateLaunchTemplate.
func (mr *MockEC2APIMockRecorder) CreateLaunchTemplate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplate), arg0)
}

// CreateLaunchTemplateRequest mocks base method.
func (m *MockEC2API) CreateLaunchTemplateRequest(arg0 *ec2.CreateLaunchTemplateInput) (*request.Request, *ec2.CreateLaunchTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLaunchTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateLaunchTemplateOutput)
	return ret0, ret1
}

// CreateLaunchTemplateRequest indicates an expected call of CreateLaunchTemplateRequest.
func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateRequest), arg0)
}

// CreateLaunchTemplateVersion mocks base method.
func (m *MockEC2API) CreateLaunchTemplateVersion(arg0 *ec2.CreateLaunchTemplateVersionInput) (*ec2.CreateLaunchTemplateVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLaunchTemplateVersion", arg0)
	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLaunchTemplateVersion indicates an expected call of CreateLaunchTemplateVersion.
func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersion(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersion", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersion), arg0)
}

// CreateLaunchTemplateVersionRequest mocks base method.
func (m *MockEC2API) CreateLaunchTemplateVersionRequest(arg0 *ec2.CreateLaunchTemplateVersionInput) (*request.Request, *ec2.CreateLaunchTemplateVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateLaunchTemplateVersionOutput)
	return ret0, ret1
}

// CreateLaunchTemplateVersionRequest indicates an expected call of CreateLaunchTemplateVersionRequest.
func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersionRequest), arg0)
}

// CreateLaunchTemplateVersionWithContext mocks base method.
func (m *MockEC2API) CreateLaunchTemplateVersionWithContext(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateVersionInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateVersionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLaunchTemplateWithContext mocks base method.
func (m *MockEC2API) CreateLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateLaunchTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLocalGatewayRoute mocks base method.
func (m *MockEC2API) CreateLocalGatewayRoute(arg0 *ec2.CreateLocalGatewayRouteInput) (*ec2.CreateLocalGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalGatewayRoute", arg0)
	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLocalGatewayRoute indicates an expected call of CreateLocalGatewayRoute.
func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRoute), arg0)
}

// CreateLocalGatewayRouteRequest mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteRequest(arg0 *ec2.CreateLocalGatewayRouteInput) (*request.Request, *ec2.CreateLocalGatewayRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteOutput)
	return ret0, ret1
}

// CreateLocalGatewayRouteRequest indicates an expected call of CreateLocalGatewayRouteRequest.
func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteRequest), arg0)
}

// CreateLocalGatewayRouteTable mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTable(arg0 *ec2.CreateLocalGatewayRouteTableInput) (*ec2.CreateLocalGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLocalGatewayRouteTable indicates an expected call of CreateLocalGatewayRouteTable.
func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTable), arg0)
}

// CreateLocalGatewayRouteTableRequest mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTableRequest(arg0 *ec2.CreateLocalGatewayRouteTableInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableOutput)
	return ret0, ret1
}

// CreateLocalGatewayRouteTableRequest indicates an expected call of CreateLocalGatewayRouteTableRequest.
func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableRequest), arg0)
}

// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation", arg0)
	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation indicates an expected call of CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation.
func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation), arg0)
}

// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
	return ret0, ret1
}

// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest indicates an expected call of CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest.
func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest), arg0)
}

// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLocalGatewayRouteTableVpcAssociation mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociation(arg0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociation", arg0)
	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLocalGatewayRouteTableVpcAssociation indicates an expected call of CreateLocalGatewayRouteTableVpcAssociation.
func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociation), arg0)
}

// CreateLocalGatewayRouteTableVpcAssociationRequest mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
	return ret0, ret1
}

// CreateLocalGatewayRouteTableVpcAssociationRequest indicates an expected call of CreateLocalGatewayRouteTableVpcAssociationRequest.
func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociationRequest), arg0)
}

// CreateLocalGatewayRouteTableVpcAssociationWithContext mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociationWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLocalGatewayRouteTableWithContext mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateLocalGatewayRouteWithContext mocks base method.
func (m *MockEC2API) CreateLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateLocalGatewayRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateManagedPrefixList mocks base method.
func (m *MockEC2API) CreateManagedPrefixList(arg0 *ec2.CreateManagedPrefixListInput) (*ec2.CreateManagedPrefixListOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateManagedPrefixList", arg0)
	ret0, _ := ret[0].(*ec2.CreateManagedPrefixListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateManagedPrefixList indicates an expected call of CreateManagedPrefixList.
func (mr *MockEC2APIMockRecorder) CreateManagedPrefixList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).CreateManagedPrefixList), arg0)
}

// CreateManagedPrefixListRequest mocks base method.
func (m *MockEC2API) CreateManagedPrefixListRequest(arg0 *ec2.CreateManagedPrefixListInput) (*request.Request, *ec2.CreateManagedPrefixListOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateManagedPrefixListRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateManagedPrefixListOutput)
	return ret0, ret1
}

// CreateManagedPrefixListRequest indicates an expected call of CreateManagedPrefixListRequest.
func (mr *MockEC2APIMockRecorder) CreateManagedPrefixListRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).CreateManagedPrefixListRequest), arg0)
}

// CreateManagedPrefixListWithContext mocks base method.
func (m *MockEC2API) CreateManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.CreateManagedPrefixListInput, arg2 ...request.Option) (*ec2.CreateManagedPrefixListOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateManagedPrefixListWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateManagedPrefixListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNatGateway mocks base method.
func (m *MockEC2API) CreateNatGateway(arg0 *ec2.CreateNatGatewayInput) (*ec2.CreateNatGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNatGateway", arg0)
	ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNatGateway indicates an expected call of CreateNatGateway.
func (mr *MockEC2APIMockRecorder) CreateNatGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGateway", reflect.TypeOf((*MockEC2API)(nil).CreateNatGateway), arg0)
}

// CreateNatGatewayRequest mocks base method.
func (m *MockEC2API) CreateNatGatewayRequest(arg0 *ec2.CreateNatGatewayInput) (*request.Request, *ec2.CreateNatGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNatGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateNatGatewayOutput)
	return ret0, ret1
}

// CreateNatGatewayRequest indicates an expected call of CreateNatGatewayRequest.
func (mr *MockEC2APIMockRecorder) CreateNatGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNatGatewayRequest), arg0)
}

// CreateNatGatewayWithContext mocks base method.
func (m *MockEC2API) CreateNatGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateNatGatewayInput, arg2 ...request.Option) (*ec2.CreateNatGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNatGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetworkAcl mocks base method.
func (m *MockEC2API) CreateNetworkAcl(arg0 *ec2.CreateNetworkAclInput) (*ec2.CreateNetworkAclOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkAcl", arg0)
	ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNetworkAcl indicates an expected call of CreateNetworkAcl.
func (mr *MockEC2APIMockRecorder) CreateNetworkAcl(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAcl), arg0)
}

// CreateNetworkAclEntry mocks base method.
func (m *MockEC2API) CreateNetworkAclEntry(arg0 *ec2.CreateNetworkAclEntryInput) (*ec2.CreateNetworkAclEntryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkAclEntry", arg0)
	ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNetworkAclEntry indicates an expected call of CreateNetworkAclEntry.
func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntry(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntry), arg0)
}

// CreateNetworkAclEntryRequest mocks base method.
func (m *MockEC2API) CreateNetworkAclEntryRequest(arg0 *ec2.CreateNetworkAclEntryInput) (*request.Request, *ec2.CreateNetworkAclEntryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkAclEntryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateNetworkAclEntryOutput)
	return ret0, ret1
}

// CreateNetworkAclEntryRequest indicates an expected call of CreateNetworkAclEntryRequest.
func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntryRequest), arg0)
}

// CreateNetworkAclEntryWithContext mocks base method.
func (m *MockEC2API) CreateNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkAclEntryInput, arg2 ...request.Option) (*ec2.CreateNetworkAclEntryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNetworkAclEntryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetworkAclRequest mocks base method.
func (m *MockEC2API) CreateNetworkAclRequest(arg0 *ec2.CreateNetworkAclInput) (*request.Request, *ec2.CreateNetworkAclOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkAclRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateNetworkAclOutput)
	return ret0, ret1
}

// CreateNetworkAclRequest indicates an expected call of CreateNetworkAclRequest.
func (mr *MockEC2APIMockRecorder) CreateNetworkAclRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclRequest), arg0)
}

// CreateNetworkAclWithContext mocks base method.
func (m *MockEC2API) CreateNetworkAclWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkAclInput, arg2 ...request.Option) (*ec2.CreateNetworkAclOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNetworkAclWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetworkInsightsAccessScope mocks base method.
func (m *MockEC2API) CreateNetworkInsightsAccessScope(arg0 *ec2.CreateNetworkInsightsAccessScopeInput) (*ec2.CreateNetworkInsightsAccessScopeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScope", arg0)
	ret0, _ := ret[0].(*ec2.CreateNetworkInsightsAccessScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNetworkInsightsAccessScope indicates an expected call of CreateNetworkInsightsAccessScope.
func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsAccessScope(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsAccessScope", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsAccessScope), arg0)
}

// CreateNetworkInsightsAccessScopeRequest mocks base method.
func (m *MockEC2API) CreateNetworkInsightsAccessScopeRequest(arg0 *ec2.CreateNetworkInsightsAccessScopeInput) (*request.Request, *ec2.CreateNetworkInsightsAccessScopeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScopeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateNetworkInsightsAccessScopeOutput)
	return ret0, ret1
}

// CreateNetworkInsightsAccessScopeRequest indicates an expected call of CreateNetworkInsightsAccessScopeRequest.
func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsAccessScopeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsAccessScopeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsAccessScopeRequest), arg0)
}

// CreateNetworkInsightsAccessScopeWithContext mocks base method.
func (m *MockEC2API) CreateNetworkInsightsAccessScopeWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInsightsAccessScopeInput, arg2 ...request.Option) (*ec2.CreateNetworkInsightsAccessScopeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScopeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateNetworkInsightsAccessScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetworkInsightsPath mocks base method.
func (m *MockEC2API) CreateNetworkInsightsPath(arg0 *ec2.CreateNetworkInsightsPathInput) (*ec2.CreateNetworkInsightsPathOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkInsightsPath", arg0)
	ret0, _ := ret[0].(*ec2.CreateNetworkInsightsPathOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNetworkInsightsPath indicates an expected call of CreateNetworkInsightsPath.
func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsPath(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsPath", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsPath), arg0)
}

// CreateNetworkInsightsPathRequest mocks base method.
func (m *MockEC2API) CreateNetworkInsightsPathRequest(arg0 *ec2.CreateNetworkInsightsPathInput) (*request.Request, *ec2.CreateNetworkInsightsPathOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkInsightsPathRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateNetworkInsightsPathOutput)
	return ret0, ret1
}

// CreateNetworkInsightsPathRequest indicates an expected call of CreateNetworkInsightsPathRequest.
func (mr *MockEC2APIMockRecorder) CreateNetworkInsightsPathRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsPathRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInsightsPathRequest), arg0)
}

// CreateNetworkInsightsPathWithContext mocks base method.
func (m *MockEC2API) CreateNetworkInsightsPathWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInsightsPathInput, arg2 ...request.Option) (*ec2.CreateNetworkInsightsPathOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNetworkInsightsPathWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateNetworkInsightsPathOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetworkInterface mocks base method.
func (m *MockEC2API) CreateNetworkInterface(arg0 *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkInterface", arg0)
	ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNetworkInterface indicates an expected call of CreateNetworkInterface.
func (mr *MockEC2APIMockRecorder) CreateNetworkInterface(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterface), arg0)
}

// CreateNetworkInterfacePermission mocks base method.
func (m *MockEC2API) CreateNetworkInterfacePermission(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*ec2.CreateNetworkInterfacePermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkInterfacePermission", arg0)
	ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNetworkInterfacePermission indicates an expected call of CreateNetworkInterfacePermission.
func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermission(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermission), arg0)
}

// CreateNetworkInterfacePermissionRequest mocks base method.
func (m *MockEC2API) CreateNetworkInterfacePermissionRequest(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*request.Request, *ec2.CreateNetworkInterfacePermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateNetworkInterfacePermissionOutput)
	return ret0, ret1
}

// CreateNetworkInterfacePermissionRequest indicates an expected call of CreateNetworkInterfacePermissionRequest.
func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermissionRequest), arg0)
}

// CreateNetworkInterfacePermissionWithContext mocks base method.
func (m *MockEC2API) CreateNetworkInterfacePermissionWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfacePermissionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetworkInterfaceRequest mocks base method.
func (m *MockEC2API) CreateNetworkInterfaceRequest(arg0 *ec2.CreateNetworkInterfaceInput) (*request.Request, *ec2.CreateNetworkInterfaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkInterfaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateNetworkInterfaceOutput)
	return ret0, ret1
}

// CreateNetworkInterfaceRequest indicates an expected call of CreateNetworkInterfaceRequest.
func (mr *MockEC2APIMockRecorder) CreateNetworkInterfaceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfaceRequest), arg0)
}

// CreateNetworkInterfaceWithContext mocks base method.
func (m *MockEC2API) CreateNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInterfaceInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNetworkInterfaceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePlacementGroup mocks base method.
func (m *MockEC2API) CreatePlacementGroup(arg0 *ec2.CreatePlacementGroupInput) (*ec2.CreatePlacementGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePlacementGroup", arg0)
	ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePlacementGroup indicates an expected call of CreatePlacementGroup.
func (mr *MockEC2APIMockRecorder) CreatePlacementGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroup), arg0)
}

// CreatePlacementGroupRequest mocks base method.
func (m *MockEC2API) CreatePlacementGroupRequest(arg0 *ec2.CreatePlacementGroupInput) (*request.Request, *ec2.CreatePlacementGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePlacementGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreatePlacementGroupOutput)
	return ret0, ret1
}

// CreatePlacementGroupRequest indicates an expected call of CreatePlacementGroupRequest.
func (mr *MockEC2APIMockRecorder) CreatePlacementGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupRequest), arg0)
}

// CreatePlacementGroupWithContext mocks base method.
func (m *MockEC2API) CreatePlacementGroupWithContext(arg0 context.Context, arg1 *ec2.CreatePlacementGroupInput, arg2 ...request.Option) (*ec2.CreatePlacementGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePlacementGroupWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePublicIpv4Pool mocks base method.
func (m *MockEC2API) CreatePublicIpv4Pool(arg0 *ec2.CreatePublicIpv4PoolInput) (*ec2.CreatePublicIpv4PoolOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePublicIpv4Pool", arg0)
	ret0, _ := ret[0].(*ec2.CreatePublicIpv4PoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePublicIpv4Pool indicates an expected call of CreatePublicIpv4Pool.
func (mr *MockEC2APIMockRecorder) CreatePublicIpv4Pool(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePublicIpv4Pool", reflect.TypeOf((*MockEC2API)(nil).CreatePublicIpv4Pool), arg0)
}

// CreatePublicIpv4PoolRequest mocks base method.
func (m *MockEC2API) CreatePublicIpv4PoolRequest(arg0 *ec2.CreatePublicIpv4PoolInput) (*request.Request, *ec2.CreatePublicIpv4PoolOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePublicIpv4PoolRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreatePublicIpv4PoolOutput)
	return ret0, ret1
}

// CreatePublicIpv4PoolRequest indicates an expected call of CreatePublicIpv4PoolRequest.
func (mr *MockEC2APIMockRecorder) CreatePublicIpv4PoolRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePublicIpv4PoolRequest", reflect.TypeOf((*MockEC2API)(nil).CreatePublicIpv4PoolRequest), arg0)
}

// CreatePublicIpv4PoolWithContext mocks base method.
func (m *MockEC2API) CreatePublicIpv4PoolWithContext(arg0 context.Context, arg1 *ec2.CreatePublicIpv4PoolInput, arg2 ...request.Option) (*ec2.CreatePublicIpv4PoolOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePublicIpv4PoolWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreatePublicIpv4PoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateReplaceRootVolumeTask mocks base method.
func (m *MockEC2API) CreateReplaceRootVolumeTask(arg0 *ec2.CreateReplaceRootVolumeTaskInput) (*ec2.CreateReplaceRootVolumeTaskOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTask", arg0)
	ret0, _ := ret[0].(*ec2.CreateReplaceRootVolumeTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReplaceRootVolumeTask indicates an expected call of CreateReplaceRootVolumeTask.
func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTask(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTask", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTask), arg0)
}

// CreateReplaceRootVolumeTaskRequest mocks base method.
func (m *MockEC2API) CreateReplaceRootVolumeTaskRequest(arg0 *ec2.CreateReplaceRootVolumeTaskInput) (*request.Request, *ec2.CreateReplaceRootVolumeTaskOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateReplaceRootVolumeTaskOutput)
	return ret0, ret1
}

// CreateReplaceRootVolumeTaskRequest indicates an expected call of CreateReplaceRootVolumeTaskRequest.
func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTaskRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTaskRequest), arg0)
}

// CreateReplaceRootVolumeTaskWithContext mocks base method.
func (m *MockEC2API) CreateReplaceRootVolumeTaskWithContext(arg0 context.Context, arg1 *ec2.CreateReplaceRootVolumeTaskInput, arg2 ...request.Option) (*ec2.CreateReplaceRootVolumeTaskOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateReplaceRootVolumeTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateReservedInstancesListing mocks base method.
func (m *MockEC2API) CreateReservedInstancesListing(arg0 *ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateReservedInstancesListing", arg0)
	ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReservedInstancesListing indicates an expected call of CreateReservedInstancesListing.
func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListing(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListing), arg0)
}

// CreateReservedInstancesListingRequest mocks base method.
func (m *MockEC2API) CreateReservedInstancesListingRequest(arg0 *ec2.CreateReservedInstancesListingInput) (*request.Request, *ec2.CreateReservedInstancesListingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateReservedInstancesListingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateReservedInstancesListingOutput)
	return ret0, ret1
}

// CreateReservedInstancesListingRequest indicates an expected call of CreateReservedInstancesListingRequest.
func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingRequest), arg0)
}

// CreateReservedInstancesListingWithContext mocks base method.
func (m *MockEC2API) CreateReservedInstancesListingWithContext(arg0 context.Context, arg1 *ec2.CreateReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CreateReservedInstancesListingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateReservedInstancesListingWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRestoreImageTask mocks base method.
func (m *MockEC2API) CreateRestoreImageTask(arg0 *ec2.CreateRestoreImageTaskInput) (*ec2.CreateRestoreImageTaskOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRestoreImageTask", arg0)
	ret0, _ := ret[0].(*ec2.CreateRestoreImageTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRestoreImageTask indicates an expected call of CreateRestoreImageTask.
func (mr *MockEC2APIMockRecorder) CreateRestoreImageTask(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRestoreImageTask", reflect.TypeOf((*MockEC2API)(nil).CreateRestoreImageTask), arg0)
}

// CreateRestoreImageTaskRequest mocks base method.
func (m *MockEC2API) CreateRestoreImageTaskRequest(arg0 *ec2.CreateRestoreImageTaskInput) (*request.Request, *ec2.CreateRestoreImageTaskOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRestoreImageTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateRestoreImageTaskOutput)
	return ret0, ret1
}

// CreateRestoreImageTaskRequest indicates an expected call of CreateRestoreImageTaskRequest.
func (mr *MockEC2APIMockRecorder) CreateRestoreImageTaskRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRestoreImageTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRestoreImageTaskRequest), arg0)
}

// CreateRestoreImageTaskWithContext mocks base method.
func (m *MockEC2API) CreateRestoreImageTaskWithContext(arg0 context.Context, arg1 *ec2.CreateRestoreImageTaskInput, arg2 ...request.Option) (*ec2.CreateRestoreImageTaskOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRestoreImageTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateRestoreImageTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRoute mocks base method.
func (m *MockEC2API) CreateRoute(arg0 *ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRoute", arg0)
	ret0, _ := ret[0].(*ec2.CreateRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRoute indicates an expected call of CreateRoute.
func (mr *MockEC2APIMockRecorder) CreateRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockEC2API)(nil).CreateRoute), arg0)
}

// CreateRouteRequest mocks base method.
func (m *MockEC2API) CreateRouteRequest(arg0 *ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateRouteOutput)
	return ret0, ret1
}

// CreateRouteRequest indicates an expected call of CreateRouteRequest.
func (mr *MockEC2APIMockRecorder) CreateRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteRequest), arg0)
}

// CreateRouteTable mocks base method.
func (m *MockEC2API) CreateRouteTable(arg0 *ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.CreateRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRouteTable indicates an expected call of CreateRouteTable.
func (mr *MockEC2APIMockRecorder) CreateRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTable), arg0)
}

// CreateRouteTableRequest mocks base method.
func (m *MockEC2API) CreateRouteTableRequest(arg0 *ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateRouteTableOutput)
	return ret0, ret1
}

// CreateRouteTableRequest indicates an expected call of CreateRouteTableRequest.
func (mr *MockEC2APIMockRecorder) CreateRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTableRequest), arg0)
}

// CreateRouteTableWithContext mocks base method.
func (m *MockEC2API) CreateRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateRouteTableInput, arg2 ...request.Option) (*ec2.CreateRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateRouteWithContext mocks base method.
func (m *MockEC2API) CreateRouteWithContext(arg0 context.Context, arg1 *ec2.CreateRouteInput, arg2 ...request.Option) (*ec2.CreateRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSecurityGroup mocks base method.
func (m *MockEC2API) CreateSecurityGroup(arg0 *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecurityGroup", arg0)
	ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSecurityGroup indicates an expected call of CreateSecurityGroup.
func (mr *MockEC2APIMockRecorder) CreateSecurityGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroup), arg0)
}

// CreateSecurityGroupRequest mocks base method.
func (m *MockEC2API) CreateSecurityGroupRequest(arg0 *ec2.CreateSecurityGroupInput) (*request.Request, *ec2.CreateSecurityGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecurityGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateSecurityGroupOutput)
	return ret0, ret1
}

// CreateSecurityGroupRequest indicates an expected call of CreateSecurityGroupRequest.
func (mr *MockEC2APIMockRecorder) CreateSecurityGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroupRequest), arg0)
}

// CreateSecurityGroupWithContext mocks base method.
func (m *MockEC2API) CreateSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.CreateSecurityGroupInput, arg2 ...request.Option) (*ec2.CreateSecurityGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSecurityGroupWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSnapshot mocks base method.
func (m *MockEC2API) CreateSnapshot(arg0 *ec2.CreateSnapshotInput) (*ec2.Snapshot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSnapshot", arg0)
	ret0, _ := ret[0].(*ec2.Snapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSnapshot indicates an expected call of CreateSnapshot.
func (mr *MockEC2APIMockRecorder) CreateSnapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshot), arg0)
}

// CreateSnapshotRequest mocks base method.
func (m *MockEC2API) CreateSnapshotRequest(arg0 *ec2.CreateSnapshotInput) (*request.Request, *ec2.Snapshot) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.Snapshot)
	return ret0, ret1
}

// CreateSnapshotRequest indicates an expected call of CreateSnapshotRequest.
func (mr *MockEC2APIMockRecorder) CreateSnapshotRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotRequest), arg0)
}

// CreateSnapshotWithContext mocks base method.
func (m *MockEC2API) CreateSnapshotWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotInput, arg2 ...request.Option) (*ec2.Snapshot, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.Snapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSnapshots mocks base method.
func (m *MockEC2API) CreateSnapshots(arg0 *ec2.CreateSnapshotsInput) (*ec2.CreateSnapshotsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSnapshots", arg0)
	ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSnapshots indicates an expected call of CreateSnapshots.
func (mr *MockEC2APIMockRecorder) CreateSnapshots(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshots", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshots), arg0)
}

// CreateSnapshotsRequest mocks base method.
func (m *MockEC2API) CreateSnapshotsRequest(arg0 *ec2.CreateSnapshotsInput) (*request.Request, *ec2.CreateSnapshotsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSnapshotsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateSnapshotsOutput)
	return ret0, ret1
}

// CreateSnapshotsRequest indicates an expected call of CreateSnapshotsRequest.
func (mr *MockEC2APIMockRecorder) CreateSnapshotsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotsRequest), arg0)
}

// CreateSnapshotsWithContext mocks base method.
func (m *MockEC2API) CreateSnapshotsWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotsInput, arg2 ...request.Option) (*ec2.CreateSnapshotsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSnapshotsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSpotDatafeedSubscription mocks base method.
func (m *MockEC2API) CreateSpotDatafeedSubscription(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscription", arg0)
	ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSpotDatafeedSubscription indicates an expected call of CreateSpotDatafeedSubscription.
func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscription(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscription), arg0)
}

// CreateSpotDatafeedSubscriptionRequest mocks base method.
func (m *MockEC2API) CreateSpotDatafeedSubscriptionRequest(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*request.Request, *ec2.CreateSpotDatafeedSubscriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateSpotDatafeedSubscriptionOutput)
	return ret0, ret1
}

// CreateSpotDatafeedSubscriptionRequest indicates an expected call of CreateSpotDatafeedSubscriptionRequest.
func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionRequest), arg0)
}

// CreateSpotDatafeedSubscriptionWithContext mocks base method.
func (m *MockEC2API) CreateSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.CreateSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateStoreImageTask mocks base method.
func (m *MockEC2API) CreateStoreImageTask(arg0 *ec2.CreateStoreImageTaskInput) (*ec2.CreateStoreImageTaskOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStoreImageTask", arg0)
	ret0, _ := ret[0].(*ec2.CreateStoreImageTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateStoreImageTask indicates an expected call of CreateStoreImageTask.
func (mr *MockEC2APIMockRecorder) CreateStoreImageTask(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoreImageTask", reflect.TypeOf((*MockEC2API)(nil).CreateStoreImageTask), arg0)
}

// CreateStoreImageTaskRequest mocks base method.
func (m *MockEC2API) CreateStoreImageTaskRequest(arg0 *ec2.CreateStoreImageTaskInput) (*request.Request, *ec2.CreateStoreImageTaskOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStoreImageTaskRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateStoreImageTaskOutput)
	return ret0, ret1
}

// CreateStoreImageTaskRequest indicates an expected call of CreateStoreImageTaskRequest.
func (mr *MockEC2APIMockRecorder) CreateStoreImageTaskRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoreImageTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateStoreImageTaskRequest), arg0)
}

// CreateStoreImageTaskWithContext mocks base method.
func (m *MockEC2API) CreateStoreImageTaskWithContext(arg0 context.Context, arg1 *ec2.CreateStoreImageTaskInput, arg2 ...request.Option) (*ec2.CreateStoreImageTaskOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateStoreImageTaskWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateStoreImageTaskOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSubnet mocks base method.
func (m *MockEC2API) CreateSubnet(arg0 *ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSubnet", arg0)
	ret0, _ := ret[0].(*ec2.CreateSubnetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSubnet indicates an expected call of CreateSubnet.
func (mr *MockEC2APIMockRecorder) CreateSubnet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateSubnet), arg0)
}

// CreateSubnetCidrReservation mocks base method.
func (m *MockEC2API) CreateSubnetCidrReservation(arg0 *ec2.CreateSubnetCidrReservationInput) (*ec2.CreateSubnetCidrReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSubnetCidrReservation", arg0)
	ret0, _ := ret[0].(*ec2.CreateSubnetCidrReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSubnetCidrReservation indicates an expected call of CreateSubnetCidrReservation.
func (mr *MockEC2APIMockRecorder) CreateSubnetCidrReservation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetCidrReservation", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetCidrReservation), arg0)
}

// CreateSubnetCidrReservationRequest mocks base method.
func (m *MockEC2API) CreateSubnetCidrReservationRequest(arg0 *ec2.CreateSubnetCidrReservationInput) (*request.Request, *ec2.CreateSubnetCidrReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSubnetCidrReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateSubnetCidrReservationOutput)
	return ret0, ret1
}

// CreateSubnetCidrReservationRequest indicates an expected call of CreateSubnetCidrReservationRequest.
func (mr *MockEC2APIMockRecorder) CreateSubnetCidrReservationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetCidrReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetCidrReservationRequest), arg0)
}

// CreateSubnetCidrReservationWithContext mocks base method.
func (m *MockEC2API) CreateSubnetCidrReservationWithContext(arg0 context.Context, arg1 *ec2.CreateSubnetCidrReservationInput, arg2 ...request.Option) (*ec2.CreateSubnetCidrReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSubnetCidrReservationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateSubnetCidrReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSubnetRequest mocks base method.
func (m *MockEC2API) CreateSubnetRequest(arg0 *ec2.CreateSubnetInput) (*request.Request, *ec2.CreateSubnetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSubnetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateSubnetOutput)
	return ret0, ret1
}

// CreateSubnetRequest indicates an expected call of CreateSubnetRequest.
func (mr *MockEC2APIMockRecorder) CreateSubnetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetRequest), arg0)
}

// CreateSubnetWithContext mocks base method.
func (m *MockEC2API) CreateSubnetWithContext(arg0 context.Context, arg1 *ec2.CreateSubnetInput, arg2 ...request.Option) (*ec2.CreateSubnetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSubnetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateSubnetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTags mocks base method.
func (m *MockEC2API) CreateTags(arg0 *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTags", arg0)
	ret0, _ := ret[0].(*ec2.CreateTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTags indicates an expected call of CreateTags.
func (mr *MockEC2APIMockRecorder) CreateTags(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2API)(nil).CreateTags), arg0)
}

// CreateTagsRequest mocks base method.
func (m *MockEC2API) CreateTagsRequest(arg0 *ec2.CreateTagsInput) (*request.Request, *ec2.CreateTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTagsOutput)
	return ret0, ret1
}

// CreateTagsRequest indicates an expected call of CreateTagsRequest.
func (mr *MockEC2APIMockRecorder) CreateTagsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTagsRequest), arg0)
}

// CreateTagsWithContext mocks base method.
func (m *MockEC2API) CreateTagsWithContext(arg0 context.Context, arg1 *ec2.CreateTagsInput, arg2 ...request.Option) (*ec2.CreateTagsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTagsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTrafficMirrorFilter mocks base method.
func (m *MockEC2API) CreateTrafficMirrorFilter(arg0 *ec2.CreateTrafficMirrorFilterInput) (*ec2.CreateTrafficMirrorFilterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilter", arg0)
	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficMirrorFilter indicates an expected call of CreateTrafficMirrorFilter.
func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilter(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilter), arg0)
}

// CreateTrafficMirrorFilterRequest mocks base method.
func (m *MockEC2API) CreateTrafficMirrorFilterRequest(arg0 *ec2.CreateTrafficMirrorFilterInput) (*request.Request, *ec2.CreateTrafficMirrorFilterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterOutput)
	return ret0, ret1
}

// CreateTrafficMirrorFilterRequest indicates an expected call of CreateTrafficMirrorFilterRequest.
func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRequest), arg0)
}

// CreateTrafficMirrorFilterRule mocks base method.
func (m *MockEC2API) CreateTrafficMirrorFilterRule(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRule", arg0)
	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficMirrorFilterRule indicates an expected call of CreateTrafficMirrorFilterRule.
func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRule), arg0)
}

// CreateTrafficMirrorFilterRuleRequest mocks base method.
func (m *MockEC2API) CreateTrafficMirrorFilterRuleRequest(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*request.Request, *ec2.CreateTrafficMirrorFilterRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterRuleOutput)
	return ret0, ret1
}

// CreateTrafficMirrorFilterRuleRequest indicates an expected call of CreateTrafficMirrorFilterRuleRequest.
func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleRequest), arg0)
}

// CreateTrafficMirrorFilterRuleWithContext mocks base method.
func (m *MockEC2API) CreateTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTrafficMirrorFilterWithContext mocks base method.
func (m *MockEC2API) CreateTrafficMirrorFilterWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTrafficMirrorSession mocks base method.
func (m *MockEC2API) CreateTrafficMirrorSession(arg0 *ec2.CreateTrafficMirrorSessionInput) (*ec2.CreateTrafficMirrorSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrafficMirrorSession", arg0)
	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficMirrorSession indicates an expected call of CreateTrafficMirrorSession.
func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSession(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSession), arg0)
}

// CreateTrafficMirrorSessionRequest mocks base method.
func (m *MockEC2API) CreateTrafficMirrorSessionRequest(arg0 *ec2.CreateTrafficMirrorSessionInput) (*request.Request, *ec2.CreateTrafficMirrorSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorSessionOutput)
	return ret0, ret1
}

// CreateTrafficMirrorSessionRequest indicates an expected call of CreateTrafficMirrorSessionRequest.
func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionRequest), arg0)
}

// CreateTrafficMirrorSessionWithContext mocks base method.
func (m *MockEC2API) CreateTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTrafficMirrorTarget mocks base method.
func (m *MockEC2API) CreateTrafficMirrorTarget(arg0 *ec2.CreateTrafficMirrorTargetInput) (*ec2.CreateTrafficMirrorTargetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrafficMirrorTarget", arg0)
	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrafficMirrorTarget indicates an expected call of CreateTrafficMirrorTarget.
func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTarget(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTarget), arg0)
}

// CreateTrafficMirrorTargetRequest mocks base method.
func (m *MockEC2API) CreateTrafficMirrorTargetRequest(arg0 *ec2.CreateTrafficMirrorTargetInput) (*request.Request, *ec2.CreateTrafficMirrorTargetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorTargetOutput)
	return ret0, ret1
}

// CreateTrafficMirrorTargetRequest indicates an expected call of CreateTrafficMirrorTargetRequest.
func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetRequest), arg0)
}

// CreateTrafficMirrorTargetWithContext mocks base method.
func (m *MockEC2API) CreateTrafficMirrorTargetWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorTargetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGateway mocks base method.
func (m *MockEC2API) CreateTransitGateway(arg0 *ec2.CreateTransitGatewayInput) (*ec2.CreateTransitGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGateway", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGateway indicates an expected call of CreateTransitGateway.
func (mr *MockEC2APIMockRecorder) CreateTransitGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGateway", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGateway), arg0)
}

// CreateTransitGatewayConnect mocks base method.
func (m *MockEC2API) CreateTransitGatewayConnect(arg0 *ec2.CreateTransitGatewayConnectInput) (*ec2.CreateTransitGatewayConnectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayConnect", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayConnect indicates an expected call of CreateTransitGatewayConnect.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnect(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnect", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnect), arg0)
}

// CreateTransitGatewayConnectPeer mocks base method.
func (m *MockEC2API) CreateTransitGatewayConnectPeer(arg0 *ec2.CreateTransitGatewayConnectPeerInput) (*ec2.CreateTransitGatewayConnectPeerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeer", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectPeerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayConnectPeer indicates an expected call of CreateTransitGatewayConnectPeer.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectPeer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeer", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectPeer), arg0)
}

// CreateTransitGatewayConnectPeerRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayConnectPeerRequest(arg0 *ec2.CreateTransitGatewayConnectPeerInput) (*request.Request, *ec2.CreateTransitGatewayConnectPeerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayConnectPeerOutput)
	return ret0, ret1
}

// CreateTransitGatewayConnectPeerRequest indicates an expected call of CreateTransitGatewayConnectPeerRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectPeerRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeerRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectPeerRequest), arg0)
}

// CreateTransitGatewayConnectPeerWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayConnectPeerWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayConnectPeerInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayConnectPeerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeerWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectPeerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayConnectRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayConnectRequest(arg0 *ec2.CreateTransitGatewayConnectInput) (*request.Request, *ec2.CreateTransitGatewayConnectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayConnectOutput)
	return ret0, ret1
}

// CreateTransitGatewayConnectRequest indicates an expected call of CreateTransitGatewayConnectRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayConnectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayConnectRequest), arg0)
}

// CreateTransitGatewayConnectWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayConnectWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayConnectInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayConnectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayConnectWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayMulticastDomain mocks base method.
func (m *MockEC2API) CreateTransitGatewayMulticastDomain(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomain", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayMulticastDomain indicates an expected call of CreateTransitGatewayMulticastDomain.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomain), arg0)
}

// CreateTransitGatewayMulticastDomainRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayMulticastDomainRequest(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.CreateTransitGatewayMulticastDomainOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayMulticastDomainOutput)
	return ret0, ret1
}

// CreateTransitGatewayMulticastDomainRequest indicates an expected call of CreateTransitGatewayMulticastDomainRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainRequest), arg0)
}

// CreateTransitGatewayMulticastDomainWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayPeeringAttachment mocks base method.
func (m *MockEC2API) CreateTransitGatewayPeeringAttachment(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachment", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayPeeringAttachment indicates an expected call of CreateTransitGatewayPeeringAttachment.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachment), arg0)
}

// CreateTransitGatewayPeeringAttachmentRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentRequest(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayPeeringAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
	return ret0, ret1
}

// CreateTransitGatewayPeeringAttachmentRequest indicates an expected call of CreateTransitGatewayPeeringAttachmentRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentRequest), arg0)
}

// CreateTransitGatewayPeeringAttachmentWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayPolicyTable mocks base method.
func (m *MockEC2API) CreateTransitGatewayPolicyTable(arg0 *ec2.CreateTransitGatewayPolicyTableInput) (*ec2.CreateTransitGatewayPolicyTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTable", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPolicyTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayPolicyTable indicates an expected call of CreateTransitGatewayPolicyTable.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPolicyTable), arg0)
}

// CreateTransitGatewayPolicyTableRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayPolicyTableRequest(arg0 *ec2.CreateTransitGatewayPolicyTableInput) (*request.Request, *ec2.CreateTransitGatewayPolicyTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayPolicyTableOutput)
	return ret0, ret1
}

// CreateTransitGatewayPolicyTableRequest indicates an expected call of CreateTransitGatewayPolicyTableRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPolicyTableRequest), arg0)
}

// CreateTransitGatewayPolicyTableWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPolicyTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPolicyTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayPrefixListReference mocks base method.
func (m *MockEC2API) CreateTransitGatewayPrefixListReference(arg0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReference", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayPrefixListReference indicates an expected call of CreateTransitGatewayPrefixListReference.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPrefixListReference), arg0)
}

// CreateTransitGatewayPrefixListReferenceRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayPrefixListReferenceRequest(arg0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.CreateTransitGatewayPrefixListReferenceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReferenceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
	return ret0, ret1
}

// CreateTransitGatewayPrefixListReferenceRequest indicates an expected call of CreateTransitGatewayPrefixListReferenceRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPrefixListReferenceRequest), arg0)
}

// CreateTransitGatewayPrefixListReferenceWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReferenceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayPrefixListReferenceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayRequest(arg0 *ec2.CreateTransitGatewayInput) (*request.Request, *ec2.CreateTransitGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayOutput)
	return ret0, ret1
}

// CreateTransitGatewayRequest indicates an expected call of CreateTransitGatewayRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRequest), arg0)
}

// CreateTransitGatewayRoute mocks base method.
func (m *MockEC2API) CreateTransitGatewayRoute(arg0 *ec2.CreateTransitGatewayRouteInput) (*ec2.CreateTransitGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayRoute", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayRoute indicates an expected call of CreateTransitGatewayRoute.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRoute), arg0)
}

// CreateTransitGatewayRouteRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayRouteRequest(arg0 *ec2.CreateTransitGatewayRouteInput) (*request.Request, *ec2.CreateTransitGatewayRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteOutput)
	return ret0, ret1
}

// CreateTransitGatewayRouteRequest indicates an expected call of CreateTransitGatewayRouteRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteRequest), arg0)
}

// CreateTransitGatewayRouteTable mocks base method.
func (m *MockEC2API) CreateTransitGatewayRouteTable(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*ec2.CreateTransitGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayRouteTable indicates an expected call of CreateTransitGatewayRouteTable.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTable), arg0)
}

// CreateTransitGatewayRouteTableAnnouncement mocks base method.
func (m *MockEC2API) CreateTransitGatewayRouteTableAnnouncement(arg0 *ec2.CreateTransitGatewayRouteTableAnnouncementInput) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncement", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayRouteTableAnnouncement indicates an expected call of CreateTransitGatewayRouteTableAnnouncement.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableAnnouncement(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableAnnouncement", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableAnnouncement), arg0)
}

// CreateTransitGatewayRouteTableAnnouncementRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayRouteTableAnnouncementRequest(arg0 *ec2.CreateTransitGatewayRouteTableAnnouncementInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableAnnouncementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput)
	return ret0, ret1
}

// CreateTransitGatewayRouteTableAnnouncementRequest indicates an expected call of CreateTransitGatewayRouteTableAnnouncementRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableAnnouncementRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableAnnouncementRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableAnnouncementRequest), arg0)
}

// CreateTransitGatewayRouteTableAnnouncementWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayRouteTableAnnouncementWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteTableAnnouncementInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncementWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayRouteTableRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayRouteTableRequest(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableOutput)
	return ret0, ret1
}

// CreateTransitGatewayRouteTableRequest indicates an expected call of CreateTransitGatewayRouteTableRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableRequest), arg0)
}

// CreateTransitGatewayRouteTableWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayRouteWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayVpcAttachment mocks base method.
func (m *MockEC2API) CreateTransitGatewayVpcAttachment(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachment", arg0)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTransitGatewayVpcAttachment indicates an expected call of CreateTransitGatewayVpcAttachment.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachment), arg0)
}

// CreateTransitGatewayVpcAttachmentRequest mocks base method.
func (m *MockEC2API) CreateTransitGatewayVpcAttachmentRequest(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayVpcAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
	return ret0, ret1
}

// CreateTransitGatewayVpcAttachmentRequest indicates an expected call of CreateTransitGatewayVpcAttachmentRequest.
func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentRequest), arg0)
}

// CreateTransitGatewayVpcAttachmentWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTransitGatewayWithContext mocks base method.
func (m *MockEC2API) CreateTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTransitGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVerifiedAccessEndpoint mocks base method.
func (m *MockEC2API) CreateVerifiedAccessEndpoint(arg0 *ec2.CreateVerifiedAccessEndpointInput) (*ec2.CreateVerifiedAccessEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVerifiedAccessEndpoint indicates an expected call of CreateVerifiedAccessEndpoint.
func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessEndpoint), arg0)
}

// CreateVerifiedAccessEndpointRequest mocks base method.
func (m *MockEC2API) CreateVerifiedAccessEndpointRequest(arg0 *ec2.CreateVerifiedAccessEndpointInput) (*request.Request, *ec2.CreateVerifiedAccessEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVerifiedAccessEndpointOutput)
	return ret0, ret1
}

// CreateVerifiedAccessEndpointRequest indicates an expected call of CreateVerifiedAccessEndpointRequest.
func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessEndpointRequest), arg0)
}

// CreateVerifiedAccessEndpointWithContext mocks base method.
func (m *MockEC2API) CreateVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVerifiedAccessGroup mocks base method.
func (m *MockEC2API) CreateVerifiedAccessGroup(arg0 *ec2.CreateVerifiedAccessGroupInput) (*ec2.CreateVerifiedAccessGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVerifiedAccessGroup", arg0)
	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVerifiedAccessGroup indicates an expected call of CreateVerifiedAccessGroup.
func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessGroup", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessGroup), arg0)
}

// CreateVerifiedAccessGroupRequest mocks base method.
func (m *MockEC2API) CreateVerifiedAccessGroupRequest(arg0 *ec2.CreateVerifiedAccessGroupInput) (*request.Request, *ec2.CreateVerifiedAccessGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVerifiedAccessGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVerifiedAccessGroupOutput)
	return ret0, ret1
}

// CreateVerifiedAccessGroupRequest indicates an expected call of CreateVerifiedAccessGroupRequest.
func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessGroupRequest), arg0)
}

// CreateVerifiedAccessGroupWithContext mocks base method.
func (m *MockEC2API) CreateVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVerifiedAccessGroupWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVerifiedAccessInstance mocks base method.
func (m *MockEC2API) CreateVerifiedAccessInstance(arg0 *ec2.CreateVerifiedAccessInstanceInput) (*ec2.CreateVerifiedAccessInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVerifiedAccessInstance", arg0)
	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVerifiedAccessInstance indicates an expected call of CreateVerifiedAccessInstance.
func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessInstance", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessInstance), arg0)
}

// CreateVerifiedAccessInstanceRequest mocks base method.
func (m *MockEC2API) CreateVerifiedAccessInstanceRequest(arg0 *ec2.CreateVerifiedAccessInstanceInput) (*request.Request, *ec2.CreateVerifiedAccessInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVerifiedAccessInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVerifiedAccessInstanceOutput)
	return ret0, ret1
}

// CreateVerifiedAccessInstanceRequest indicates an expected call of CreateVerifiedAccessInstanceRequest.
func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessInstanceRequest), arg0)
}

// CreateVerifiedAccessInstanceWithContext mocks base method.
func (m *MockEC2API) CreateVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVerifiedAccessInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVerifiedAccessTrustProvider mocks base method.
func (m *MockEC2API) CreateVerifiedAccessTrustProvider(arg0 *ec2.CreateVerifiedAccessTrustProviderInput) (*ec2.CreateVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProvider", arg0)
	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVerifiedAccessTrustProvider indicates an expected call of CreateVerifiedAccessTrustProvider.
func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessTrustProvider), arg0)
}

// CreateVerifiedAccessTrustProviderRequest mocks base method.
func (m *MockEC2API) CreateVerifiedAccessTrustProviderRequest(arg0 *ec2.CreateVerifiedAccessTrustProviderInput) (*request.Request, *ec2.CreateVerifiedAccessTrustProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVerifiedAccessTrustProviderOutput)
	return ret0, ret1
}

// CreateVerifiedAccessTrustProviderRequest indicates an expected call of CreateVerifiedAccessTrustProviderRequest.
func (mr *MockEC2APIMockRecorder) CreateVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVerifiedAccessTrustProviderRequest), arg0)
}

// CreateVerifiedAccessTrustProviderWithContext mocks base method.
func (m *MockEC2API) CreateVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProviderWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVolume mocks base method.
func (m *MockEC2API) CreateVolume(arg0 *ec2.CreateVolumeInput) (*ec2.Volume, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVolume", arg0)
	ret0, _ := ret[0].(*ec2.Volume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVolume indicates an expected call of CreateVolume.
func (mr *MockEC2APIMockRecorder) CreateVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockEC2API)(nil).CreateVolume), arg0)
}

// CreateVolumeRequest mocks base method.
func (m *MockEC2API) CreateVolumeRequest(arg0 *ec2.CreateVolumeInput) (*request.Request, *ec2.Volume) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVolumeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.Volume)
	return ret0, ret1
}

// CreateVolumeRequest indicates an expected call of CreateVolumeRequest.
func (mr *MockEC2APIMockRecorder) CreateVolumeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVolumeRequest), arg0)
}

// CreateVolumeWithContext mocks base method.
func (m *MockEC2API) CreateVolumeWithContext(arg0 context.Context, arg1 *ec2.CreateVolumeInput, arg2 ...request.Option) (*ec2.Volume, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVolumeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.Volume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpc mocks base method.
func (m *MockEC2API) CreateVpc(arg0 *ec2.CreateVpcInput) (*ec2.CreateVpcOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpc", arg0)
	ret0, _ := ret[0].(*ec2.CreateVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpc indicates an expected call of CreateVpc.
func (mr *MockEC2APIMockRecorder) CreateVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpc", reflect.TypeOf((*MockEC2API)(nil).CreateVpc), arg0)
}

// CreateVpcEndpoint mocks base method.
func (m *MockEC2API) CreateVpcEndpoint(arg0 *ec2.CreateVpcEndpointInput) (*ec2.CreateVpcEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpcEndpoint indicates an expected call of CreateVpcEndpoint.
func (mr *MockEC2APIMockRecorder) CreateVpcEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpoint), arg0)
}

// CreateVpcEndpointConnectionNotification mocks base method.
func (m *MockEC2API) CreateVpcEndpointConnectionNotification(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotification", arg0)
	ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpcEndpointConnectionNotification indicates an expected call of CreateVpcEndpointConnectionNotification.
func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotification), arg0)
}

// CreateVpcEndpointConnectionNotificationRequest mocks base method.
func (m *MockEC2API) CreateVpcEndpointConnectionNotificationRequest(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.CreateVpcEndpointConnectionNotificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVpcEndpointConnectionNotificationOutput)
	return ret0, ret1
}

// CreateVpcEndpointConnectionNotificationRequest indicates an expected call of CreateVpcEndpointConnectionNotificationRequest.
func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationRequest), arg0)
}

// CreateVpcEndpointConnectionNotificationWithContext mocks base method.
func (m *MockEC2API) CreateVpcEndpointConnectionNotificationWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpcEndpointRequest mocks base method.
func (m *MockEC2API) CreateVpcEndpointRequest(arg0 *ec2.CreateVpcEndpointInput) (*request.Request, *ec2.CreateVpcEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVpcEndpointOutput)
	return ret0, ret1
}

// CreateVpcEndpointRequest indicates an expected call of CreateVpcEndpointRequest.
func (mr *MockEC2APIMockRecorder) CreateVpcEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointRequest), arg0)
}

// CreateVpcEndpointServiceConfiguration mocks base method.
func (m *MockEC2API) CreateVpcEndpointServiceConfiguration(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfiguration", arg0)
	ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpcEndpointServiceConfiguration indicates an expected call of CreateVpcEndpointServiceConfiguration.
func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfiguration), arg0)
}

// CreateVpcEndpointServiceConfigurationRequest mocks base method.
func (m *MockEC2API) CreateVpcEndpointServiceConfigurationRequest(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.CreateVpcEndpointServiceConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVpcEndpointServiceConfigurationOutput)
	return ret0, ret1
}

// CreateVpcEndpointServiceConfigurationRequest indicates an expected call of CreateVpcEndpointServiceConfigurationRequest.
func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationRequest), arg0)
}

// CreateVpcEndpointServiceConfigurationWithContext mocks base method.
func (m *MockEC2API) CreateVpcEndpointServiceConfigurationWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpcEndpointWithContext mocks base method.
func (m *MockEC2API) CreateVpcEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpcEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpcPeeringConnection mocks base method.
func (m *MockEC2API) CreateVpcPeeringConnection(arg0 *ec2.CreateVpcPeeringConnectionInput) (*ec2.CreateVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcPeeringConnection", arg0)
	ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpcPeeringConnection indicates an expected call of CreateVpcPeeringConnection.
func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnection), arg0)
}

// CreateVpcPeeringConnectionRequest mocks base method.
func (m *MockEC2API) CreateVpcPeeringConnectionRequest(arg0 *ec2.CreateVpcPeeringConnectionInput) (*request.Request, *ec2.CreateVpcPeeringConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVpcPeeringConnectionOutput)
	return ret0, ret1
}

// CreateVpcPeeringConnectionRequest indicates an expected call of CreateVpcPeeringConnectionRequest.
func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnectionRequest), arg0)
}

// CreateVpcPeeringConnectionWithContext mocks base method.
func (m *MockEC2API) CreateVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.CreateVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.CreateVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpcRequest mocks base method.
func (m *MockEC2API) CreateVpcRequest(arg0 *ec2.CreateVpcInput) (*request.Request, *ec2.CreateVpcOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpcRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVpcOutput)
	return ret0, ret1
}

// CreateVpcRequest indicates an expected call of CreateVpcRequest.
func (mr *MockEC2APIMockRecorder) CreateVpcRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcRequest), arg0)
}

// CreateVpcWithContext mocks base method.
func (m *MockEC2API) CreateVpcWithContext(arg0 context.Context, arg1 *ec2.CreateVpcInput, arg2 ...request.Option) (*ec2.CreateVpcOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpcWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpnConnection mocks base method.
func (m *MockEC2API) CreateVpnConnection(arg0 *ec2.CreateVpnConnectionInput) (*ec2.CreateVpnConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpnConnection", arg0)
	ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpnConnection indicates an expected call of CreateVpnConnection.
func (mr *MockEC2APIMockRecorder) CreateVpnConnection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnection), arg0)
}

// CreateVpnConnectionRequest mocks base method.
func (m *MockEC2API) CreateVpnConnectionRequest(arg0 *ec2.CreateVpnConnectionInput) (*request.Request, *ec2.CreateVpnConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpnConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVpnConnectionOutput)
	return ret0, ret1
}

// CreateVpnConnectionRequest indicates an expected call of CreateVpnConnectionRequest.
func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRequest), arg0)
}

// CreateVpnConnectionRoute mocks base method.
func (m *MockEC2API) CreateVpnConnectionRoute(arg0 *ec2.CreateVpnConnectionRouteInput) (*ec2.CreateVpnConnectionRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpnConnectionRoute", arg0)
	ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpnConnectionRoute indicates an expected call of CreateVpnConnectionRoute.
func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRoute), arg0)
}

// CreateVpnConnectionRouteRequest mocks base method.
func (m *MockEC2API) CreateVpnConnectionRouteRequest(arg0 *ec2.CreateVpnConnectionRouteInput) (*request.Request, *ec2.CreateVpnConnectionRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpnConnectionRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVpnConnectionRouteOutput)
	return ret0, ret1
}

// CreateVpnConnectionRouteRequest indicates an expected call of CreateVpnConnectionRouteRequest.
func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRouteRequest), arg0)
}

// CreateVpnConnectionRouteWithContext mocks base method.
func (m *MockEC2API) CreateVpnConnectionRouteWithContext(arg0 context.Context, arg1 *ec2.CreateVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpnConnectionRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpnConnectionWithContext mocks base method.
func (m *MockEC2API) CreateVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.CreateVpnConnectionInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpnConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVpnGateway mocks base method.
func (m *MockEC2API) CreateVpnGateway(arg0 *ec2.CreateVpnGatewayInput) (*ec2.CreateVpnGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpnGateway", arg0)
	ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpnGateway indicates an expected call of CreateVpnGateway.
func (mr *MockEC2APIMockRecorder) CreateVpnGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGateway", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGateway), arg0)
}

// CreateVpnGatewayRequest mocks base method.
func (m *MockEC2API) CreateVpnGatewayRequest(arg0 *ec2.CreateVpnGatewayInput) (*request.Request, *ec2.CreateVpnGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpnGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.CreateVpnGatewayOutput)
	return ret0, ret1
}

// CreateVpnGatewayRequest indicates an expected call of CreateVpnGatewayRequest.
func (mr *MockEC2APIMockRecorder) CreateVpnGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGatewayRequest), arg0)
}

// CreateVpnGatewayWithContext mocks base method.
func (m *MockEC2API) CreateVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateVpnGatewayInput, arg2 ...request.Option) (*ec2.CreateVpnGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateVpnGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCarrierGateway mocks base method.
func (m *MockEC2API) DeleteCarrierGateway(arg0 *ec2.DeleteCarrierGatewayInput) (*ec2.DeleteCarrierGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCarrierGateway", arg0)
	ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCarrierGateway indicates an expected call of DeleteCarrierGateway.
func (mr *MockEC2APIMockRecorder) DeleteCarrierGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGateway), arg0)
}

// DeleteCarrierGatewayRequest mocks base method.
func (m *MockEC2API) DeleteCarrierGatewayRequest(arg0 *ec2.DeleteCarrierGatewayInput) (*request.Request, *ec2.DeleteCarrierGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCarrierGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteCarrierGatewayOutput)
	return ret0, ret1
}

// DeleteCarrierGatewayRequest indicates an expected call of DeleteCarrierGatewayRequest.
func (mr *MockEC2APIMockRecorder) DeleteCarrierGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGatewayRequest), arg0)
}

// DeleteCarrierGatewayWithContext mocks base method.
func (m *MockEC2API) DeleteCarrierGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteCarrierGatewayInput, arg2 ...request.Option) (*ec2.DeleteCarrierGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCarrierGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteClientVpnEndpoint mocks base method.
func (m *MockEC2API) DeleteClientVpnEndpoint(arg0 *ec2.DeleteClientVpnEndpointInput) (*ec2.DeleteClientVpnEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClientVpnEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteClientVpnEndpoint indicates an expected call of DeleteClientVpnEndpoint.
func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpoint), arg0)
}

// DeleteClientVpnEndpointRequest mocks base method.
func (m *MockEC2API) DeleteClientVpnEndpointRequest(arg0 *ec2.DeleteClientVpnEndpointInput) (*request.Request, *ec2.DeleteClientVpnEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClientVpnEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteClientVpnEndpointOutput)
	return ret0, ret1
}

// DeleteClientVpnEndpointRequest indicates an expected call of DeleteClientVpnEndpointRequest.
func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpointRequest), arg0)
}

// DeleteClientVpnEndpointWithContext mocks base method.
func (m *MockEC2API) DeleteClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteClientVpnEndpointInput, arg2 ...request.Option) (*ec2.DeleteClientVpnEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteClientVpnEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteClientVpnRoute mocks base method.
func (m *MockEC2API) DeleteClientVpnRoute(arg0 *ec2.DeleteClientVpnRouteInput) (*ec2.DeleteClientVpnRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClientVpnRoute", arg0)
	ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteClientVpnRoute indicates an expected call of DeleteClientVpnRoute.
func (mr *MockEC2APIMockRecorder) DeleteClientVpnRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRoute), arg0)
}

// DeleteClientVpnRouteRequest mocks base method.
func (m *MockEC2API) DeleteClientVpnRouteRequest(arg0 *ec2.DeleteClientVpnRouteInput) (*request.Request, *ec2.DeleteClientVpnRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClientVpnRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteClientVpnRouteOutput)
	return ret0, ret1
}

// DeleteClientVpnRouteRequest indicates an expected call of DeleteClientVpnRouteRequest.
func (mr *MockEC2APIMockRecorder) DeleteClientVpnRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRouteRequest), arg0)
}

// DeleteClientVpnRouteWithContext mocks base method.
func (m *MockEC2API) DeleteClientVpnRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteClientVpnRouteInput, arg2 ...request.Option) (*ec2.DeleteClientVpnRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteClientVpnRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCoipCidr mocks base method.
func (m *MockEC2API) DeleteCoipCidr(arg0 *ec2.DeleteCoipCidrInput) (*ec2.DeleteCoipCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCoipCidr", arg0)
	ret0, _ := ret[0].(*ec2.DeleteCoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCoipCidr indicates an expected call of DeleteCoipCidr.
func (mr *MockEC2APIMockRecorder) DeleteCoipCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipCidr", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipCidr), arg0)
}

// DeleteCoipCidrRequest mocks base method.
func (m *MockEC2API) DeleteCoipCidrRequest(arg0 *ec2.DeleteCoipCidrInput) (*request.Request, *ec2.DeleteCoipCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCoipCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteCoipCidrOutput)
	return ret0, ret1
}

// DeleteCoipCidrRequest indicates an expected call of DeleteCoipCidrRequest.
func (mr *MockEC2APIMockRecorder) DeleteCoipCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipCidrRequest), arg0)
}

// DeleteCoipCidrWithContext mocks base method.
func (m *MockEC2API) DeleteCoipCidrWithContext(arg0 context.Context, arg1 *ec2.DeleteCoipCidrInput, arg2 ...request.Option) (*ec2.DeleteCoipCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCoipCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteCoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCoipPool mocks base method.
func (m *MockEC2API) DeleteCoipPool(arg0 *ec2.DeleteCoipPoolInput) (*ec2.DeleteCoipPoolOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCoipPool", arg0)
	ret0, _ := ret[0].(*ec2.DeleteCoipPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCoipPool indicates an expected call of DeleteCoipPool.
func (mr *MockEC2APIMockRecorder) DeleteCoipPool(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipPool", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipPool), arg0)
}

// DeleteCoipPoolRequest mocks base method.
func (m *MockEC2API) DeleteCoipPoolRequest(arg0 *ec2.DeleteCoipPoolInput) (*request.Request, *ec2.DeleteCoipPoolOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCoipPoolRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteCoipPoolOutput)
	return ret0, ret1
}

// DeleteCoipPoolRequest indicates an expected call of DeleteCoipPoolRequest.
func (mr *MockEC2APIMockRecorder) DeleteCoipPoolRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipPoolRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCoipPoolRequest), arg0)
}

// DeleteCoipPoolWithContext mocks base method.
func (m *MockEC2API) DeleteCoipPoolWithContext(arg0 context.Context, arg1 *ec2.DeleteCoipPoolInput, arg2 ...request.Option) (*ec2.DeleteCoipPoolOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCoipPoolWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteCoipPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCustomerGateway mocks base method.
func (m *MockEC2API) DeleteCustomerGateway(arg0 *ec2.DeleteCustomerGatewayInput) (*ec2.DeleteCustomerGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCustomerGateway", arg0)
	ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCustomerGateway indicates an expected call of DeleteCustomerGateway.
func (mr *MockEC2APIMockRecorder) DeleteCustomerGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGateway), arg0)
}

// DeleteCustomerGatewayRequest mocks base method.
func (m *MockEC2API) DeleteCustomerGatewayRequest(arg0 *ec2.DeleteCustomerGatewayInput) (*request.Request, *ec2.DeleteCustomerGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCustomerGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteCustomerGatewayOutput)
	return ret0, ret1
}

// DeleteCustomerGatewayRequest indicates an expected call of DeleteCustomerGatewayRequest.
func (mr *MockEC2APIMockRecorder) DeleteCustomerGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGatewayRequest), arg0)
}

// DeleteCustomerGatewayWithContext mocks base method.
func (m *MockEC2API) DeleteCustomerGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteCustomerGatewayInput, arg2 ...request.Option) (*ec2.DeleteCustomerGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCustomerGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDhcpOptions mocks base method.
func (m *MockEC2API) DeleteDhcpOptions(arg0 *ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDhcpOptions", arg0)
	ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDhcpOptions indicates an expected call of DeleteDhcpOptions.
func (mr *MockEC2APIMockRecorder) DeleteDhcpOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptions), arg0)
}

// DeleteDhcpOptionsRequest mocks base method.
func (m *MockEC2API) DeleteDhcpOptionsRequest(arg0 *ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDhcpOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteDhcpOptionsOutput)
	return ret0, ret1
}

// DeleteDhcpOptionsRequest indicates an expected call of DeleteDhcpOptionsRequest.
func (mr *MockEC2APIMockRecorder) DeleteDhcpOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptionsRequest), arg0)
}

// DeleteDhcpOptionsWithContext mocks base method.
func (m *MockEC2API) DeleteDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.DeleteDhcpOptionsInput, arg2 ...request.Option) (*ec2.DeleteDhcpOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDhcpOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEgressOnlyInternetGateway mocks base method.
func (m *MockEC2API) DeleteEgressOnlyInternetGateway(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGateway", arg0)
	ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteEgressOnlyInternetGateway indicates an expected call of DeleteEgressOnlyInternetGateway.
func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGateway), arg0)
}

// DeleteEgressOnlyInternetGatewayRequest mocks base method.
func (m *MockEC2API) DeleteEgressOnlyInternetGatewayRequest(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*request.Request, *ec2.DeleteEgressOnlyInternetGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteEgressOnlyInternetGatewayOutput)
	return ret0, ret1
}

// DeleteEgressOnlyInternetGatewayRequest indicates an expected call of DeleteEgressOnlyInternetGatewayRequest.
func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayRequest), arg0)
}

// DeleteEgressOnlyInternetGatewayWithContext mocks base method.
func (m *MockEC2API) DeleteEgressOnlyInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFleets mocks base method.
func (m *MockEC2API) DeleteFleets(arg0 *ec2.DeleteFleetsInput) (*ec2.DeleteFleetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFleets", arg0)
	ret0, _ := ret[0].(*ec2.DeleteFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteFleets indicates an expected call of DeleteFleets.
func (mr *MockEC2APIMockRecorder) DeleteFleets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleets", reflect.TypeOf((*MockEC2API)(nil).DeleteFleets), arg0)
}

// DeleteFleetsRequest mocks base method.
func (m *MockEC2API) DeleteFleetsRequest(arg0 *ec2.DeleteFleetsInput) (*request.Request, *ec2.DeleteFleetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFleetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteFleetsOutput)
	return ret0, ret1
}

// DeleteFleetsRequest indicates an expected call of DeleteFleetsRequest.
func (mr *MockEC2APIMockRecorder) DeleteFleetsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFleetsRequest), arg0)
}

// DeleteFleetsWithContext mocks base method.
func (m *MockEC2API) DeleteFleetsWithContext(arg0 context.Context, arg1 *ec2.DeleteFleetsInput, arg2 ...request.Option) (*ec2.DeleteFleetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteFleetsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFlowLogs mocks base method.
func (m *MockEC2API) DeleteFlowLogs(arg0 *ec2.DeleteFlowLogsInput) (*ec2.DeleteFlowLogsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFlowLogs", arg0)
	ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteFlowLogs indicates an expected call of DeleteFlowLogs.
func (mr *MockEC2APIMockRecorder) DeleteFlowLogs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogs), arg0)
}

// DeleteFlowLogsRequest mocks base method.
func (m *MockEC2API) DeleteFlowLogsRequest(arg0 *ec2.DeleteFlowLogsInput) (*request.Request, *ec2.DeleteFlowLogsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFlowLogsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteFlowLogsOutput)
	return ret0, ret1
}

// DeleteFlowLogsRequest indicates an expected call of DeleteFlowLogsRequest.
func (mr *MockEC2APIMockRecorder) DeleteFlowLogsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogsRequest), arg0)
}

// DeleteFlowLogsWithContext mocks base method.
func (m *MockEC2API) DeleteFlowLogsWithContext(arg0 context.Context, arg1 *ec2.DeleteFlowLogsInput, arg2 ...request.Option) (*ec2.DeleteFlowLogsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteFlowLogsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFpgaImage mocks base method.
func (m *MockEC2API) DeleteFpgaImage(arg0 *ec2.DeleteFpgaImageInput) (*ec2.DeleteFpgaImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFpgaImage", arg0)
	ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteFpgaImage indicates an expected call of DeleteFpgaImage.
func (mr *MockEC2APIMockRecorder) DeleteFpgaImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImage", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImage), arg0)
}

// DeleteFpgaImageRequest mocks base method.
func (m *MockEC2API) DeleteFpgaImageRequest(arg0 *ec2.DeleteFpgaImageInput) (*request.Request, *ec2.DeleteFpgaImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFpgaImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteFpgaImageOutput)
	return ret0, ret1
}

// DeleteFpgaImageRequest indicates an expected call of DeleteFpgaImageRequest.
func (mr *MockEC2APIMockRecorder) DeleteFpgaImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImageRequest), arg0)
}

// DeleteFpgaImageWithContext mocks base method.
func (m *MockEC2API) DeleteFpgaImageWithContext(arg0 context.Context, arg1 *ec2.DeleteFpgaImageInput, arg2 ...request.Option) (*ec2.DeleteFpgaImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteFpgaImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteInstanceConnectEndpoint mocks base method.
func (m *MockEC2API) DeleteInstanceConnectEndpoint(arg0 *ec2.DeleteInstanceConnectEndpointInput) (*ec2.DeleteInstanceConnectEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.DeleteInstanceConnectEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteInstanceConnectEndpoint indicates an expected call of DeleteInstanceConnectEndpoint.
func (mr *MockEC2APIMockRecorder) DeleteInstanceConnectEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceConnectEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceConnectEndpoint), arg0)
}

// DeleteInstanceConnectEndpointRequest mocks base method.
func (m *MockEC2API) DeleteInstanceConnectEndpointRequest(arg0 *ec2.DeleteInstanceConnectEndpointInput) (*request.Request, *ec2.DeleteInstanceConnectEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteInstanceConnectEndpointOutput)
	return ret0, ret1
}

// DeleteInstanceConnectEndpointRequest indicates an expected call of DeleteInstanceConnectEndpointRequest.
func (mr *MockEC2APIMockRecorder) DeleteInstanceConnectEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceConnectEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceConnectEndpointRequest), arg0)
}

// DeleteInstanceConnectEndpointWithContext mocks base method.
func (m *MockEC2API) DeleteInstanceConnectEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteInstanceConnectEndpointInput, arg2 ...request.Option) (*ec2.DeleteInstanceConnectEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteInstanceConnectEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteInstanceEventWindow mocks base method.
func (m *MockEC2API) DeleteInstanceEventWindow(arg0 *ec2.DeleteInstanceEventWindowInput) (*ec2.DeleteInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInstanceEventWindow", arg0)
	ret0, _ := ret[0].(*ec2.DeleteInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteInstanceEventWindow indicates an expected call of DeleteInstanceEventWindow.
func (mr *MockEC2APIMockRecorder) DeleteInstanceEventWindow(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceEventWindow), arg0)
}

// DeleteInstanceEventWindowRequest mocks base method.
func (m *MockEC2API) DeleteInstanceEventWindowRequest(arg0 *ec2.DeleteInstanceEventWindowInput) (*request.Request, *ec2.DeleteInstanceEventWindowOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInstanceEventWindowRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteInstanceEventWindowOutput)
	return ret0, ret1
}

// DeleteInstanceEventWindowRequest indicates an expected call of DeleteInstanceEventWindowRequest.
func (mr *MockEC2APIMockRecorder) DeleteInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInstanceEventWindowRequest), arg0)
}

// DeleteInstanceEventWindowWithContext mocks base method.
func (m *MockEC2API) DeleteInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.DeleteInstanceEventWindowInput, arg2 ...request.Option) (*ec2.DeleteInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteInstanceEventWindowWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteInternetGateway mocks base method.
func (m *MockEC2API) DeleteInternetGateway(arg0 *ec2.DeleteInternetGatewayInput) (*ec2.DeleteInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInternetGateway", arg0)
	ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteInternetGateway indicates an expected call of DeleteInternetGateway.
func (mr *MockEC2APIMockRecorder) DeleteInternetGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGateway), arg0)
}

// DeleteInternetGatewayRequest mocks base method.
func (m *MockEC2API) DeleteInternetGatewayRequest(arg0 *ec2.DeleteInternetGatewayInput) (*request.Request, *ec2.DeleteInternetGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInternetGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteInternetGatewayOutput)
	return ret0, ret1
}

// DeleteInternetGatewayRequest indicates an expected call of DeleteInternetGatewayRequest.
func (mr *MockEC2APIMockRecorder) DeleteInternetGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGatewayRequest), arg0)
}

// DeleteInternetGatewayWithContext mocks base method.
func (m *MockEC2API) DeleteInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteInternetGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIpam mocks base method.
func (m *MockEC2API) DeleteIpam(arg0 *ec2.DeleteIpamInput) (*ec2.DeleteIpamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpam", arg0)
	ret0, _ := ret[0].(*ec2.DeleteIpamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteIpam indicates an expected call of DeleteIpam.
func (mr *MockEC2APIMockRecorder) DeleteIpam(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpam", reflect.TypeOf((*MockEC2API)(nil).DeleteIpam), arg0)
}

// DeleteIpamExternalResourceVerificationToken mocks base method.
func (m *MockEC2API) DeleteIpamExternalResourceVerificationToken(arg0 *ec2.DeleteIpamExternalResourceVerificationTokenInput) (*ec2.DeleteIpamExternalResourceVerificationTokenOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamExternalResourceVerificationToken", arg0)
	ret0, _ := ret[0].(*ec2.DeleteIpamExternalResourceVerificationTokenOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteIpamExternalResourceVerificationToken indicates an expected call of DeleteIpamExternalResourceVerificationToken.
func (mr *MockEC2APIMockRecorder) DeleteIpamExternalResourceVerificationToken(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamExternalResourceVerificationToken", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamExternalResourceVerificationToken), arg0)
}

// DeleteIpamExternalResourceVerificationTokenRequest mocks base method.
func (m *MockEC2API) DeleteIpamExternalResourceVerificationTokenRequest(arg0 *ec2.DeleteIpamExternalResourceVerificationTokenInput) (*request.Request, *ec2.DeleteIpamExternalResourceVerificationTokenOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamExternalResourceVerificationTokenRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteIpamExternalResourceVerificationTokenOutput)
	return ret0, ret1
}

// DeleteIpamExternalResourceVerificationTokenRequest indicates an expected call of DeleteIpamExternalResourceVerificationTokenRequest.
func (mr *MockEC2APIMockRecorder) DeleteIpamExternalResourceVerificationTokenRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamExternalResourceVerificationTokenRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamExternalResourceVerificationTokenRequest), arg0)
}

// DeleteIpamExternalResourceVerificationTokenWithContext mocks base method.
func (m *MockEC2API) DeleteIpamExternalResourceVerificationTokenWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamExternalResourceVerificationTokenInput, arg2 ...request.Option) (*ec2.DeleteIpamExternalResourceVerificationTokenOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteIpamExternalResourceVerificationTokenWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteIpamExternalResourceVerificationTokenOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIpamPool mocks base method.
func (m *MockEC2API) DeleteIpamPool(arg0 *ec2.DeleteIpamPoolInput) (*ec2.DeleteIpamPoolOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamPool", arg0)
	ret0, _ := ret[0].(*ec2.DeleteIpamPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteIpamPool indicates an expected call of DeleteIpamPool.
func (mr *MockEC2APIMockRecorder) DeleteIpamPool(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamPool", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamPool), arg0)
}

// DeleteIpamPoolRequest mocks base method.
func (m *MockEC2API) DeleteIpamPoolRequest(arg0 *ec2.DeleteIpamPoolInput) (*request.Request, *ec2.DeleteIpamPoolOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamPoolRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteIpamPoolOutput)
	return ret0, ret1
}

// DeleteIpamPoolRequest indicates an expected call of DeleteIpamPoolRequest.
func (mr *MockEC2APIMockRecorder) DeleteIpamPoolRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamPoolRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamPoolRequest), arg0)
}

// DeleteIpamPoolWithContext mocks base method.
func (m *MockEC2API) DeleteIpamPoolWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamPoolInput, arg2 ...request.Option) (*ec2.DeleteIpamPoolOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteIpamPoolWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteIpamPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIpamRequest mocks base method.
func (m *MockEC2API) DeleteIpamRequest(arg0 *ec2.DeleteIpamInput) (*request.Request, *ec2.DeleteIpamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteIpamOutput)
	return ret0, ret1
}

// DeleteIpamRequest indicates an expected call of DeleteIpamRequest.
func (mr *MockEC2APIMockRecorder) DeleteIpamRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamRequest), arg0)
}

// DeleteIpamResourceDiscovery mocks base method.
func (m *MockEC2API) DeleteIpamResourceDiscovery(arg0 *ec2.DeleteIpamResourceDiscoveryInput) (*ec2.DeleteIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamResourceDiscovery", arg0)
	ret0, _ := ret[0].(*ec2.DeleteIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteIpamResourceDiscovery indicates an expected call of DeleteIpamResourceDiscovery.
func (mr *MockEC2APIMockRecorder) DeleteIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamResourceDiscovery), arg0)
}

// DeleteIpamResourceDiscoveryRequest mocks base method.
func (m *MockEC2API) DeleteIpamResourceDiscoveryRequest(arg0 *ec2.DeleteIpamResourceDiscoveryInput) (*request.Request, *ec2.DeleteIpamResourceDiscoveryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamResourceDiscoveryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteIpamResourceDiscoveryOutput)
	return ret0, ret1
}

// DeleteIpamResourceDiscoveryRequest indicates an expected call of DeleteIpamResourceDiscoveryRequest.
func (mr *MockEC2APIMockRecorder) DeleteIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamResourceDiscoveryRequest), arg0)
}

// DeleteIpamResourceDiscoveryWithContext mocks base method.
func (m *MockEC2API) DeleteIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.DeleteIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteIpamResourceDiscoveryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIpamScope mocks base method.
func (m *MockEC2API) DeleteIpamScope(arg0 *ec2.DeleteIpamScopeInput) (*ec2.DeleteIpamScopeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamScope", arg0)
	ret0, _ := ret[0].(*ec2.DeleteIpamScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteIpamScope indicates an expected call of DeleteIpamScope.
func (mr *MockEC2APIMockRecorder) DeleteIpamScope(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamScope", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamScope), arg0)
}

// DeleteIpamScopeRequest mocks base method.
func (m *MockEC2API) DeleteIpamScopeRequest(arg0 *ec2.DeleteIpamScopeInput) (*request.Request, *ec2.DeleteIpamScopeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIpamScopeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteIpamScopeOutput)
	return ret0, ret1
}

// DeleteIpamScopeRequest indicates an expected call of DeleteIpamScopeRequest.
func (mr *MockEC2APIMockRecorder) DeleteIpamScopeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamScopeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteIpamScopeRequest), arg0)
}

// DeleteIpamScopeWithContext mocks base method.
func (m *MockEC2API) DeleteIpamScopeWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamScopeInput, arg2 ...request.Option) (*ec2.DeleteIpamScopeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteIpamScopeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteIpamScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIpamWithContext mocks base method.
func (m *MockEC2API) DeleteIpamWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamInput, arg2 ...request.Option) (*ec2.DeleteIpamOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteIpamWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteIpamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteKeyPair mocks base method.
func (m *MockEC2API) DeleteKeyPair(arg0 *ec2.DeleteKeyPairInput) (*ec2.DeleteKeyPairOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteKeyPair", arg0)
	ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteKeyPair indicates an expected call of DeleteKeyPair.
func (mr *MockEC2APIMockRecorder) DeleteKeyPair(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPair", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPair), arg0)
}

// DeleteKeyPairRequest mocks base method.
func (m *MockEC2API) DeleteKeyPairRequest(arg0 *ec2.DeleteKeyPairInput) (*request.Request, *ec2.DeleteKeyPairOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteKeyPairRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteKeyPairOutput)
	return ret0, ret1
}

// DeleteKeyPairRequest indicates an expected call of DeleteKeyPairRequest.
func (mr *MockEC2APIMockRecorder) DeleteKeyPairRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPairRequest), arg0)
}

// DeleteKeyPairWithContext mocks base method.
func (m *MockEC2API) DeleteKeyPairWithContext(arg0 context.Context, arg1 *ec2.DeleteKeyPairInput, arg2 ...request.Option) (*ec2.DeleteKeyPairOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteKeyPairWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLaunchTemplate mocks base method.
func (m *MockEC2API) DeleteLaunchTemplate(arg0 *ec2.DeleteLaunchTemplateInput) (*ec2.DeleteLaunchTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLaunchTemplate", arg0)
	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLaunchTemplate indicates an expected call of DeleteLaunchTemplate.
func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplate), arg0)
}

// DeleteLaunchTemplateRequest mocks base method.
func (m *MockEC2API) DeleteLaunchTemplateRequest(arg0 *ec2.DeleteLaunchTemplateInput) (*request.Request, *ec2.DeleteLaunchTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLaunchTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateOutput)
	return ret0, ret1
}

// DeleteLaunchTemplateRequest indicates an expected call of DeleteLaunchTemplateRequest.
func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateRequest), arg0)
}

// DeleteLaunchTemplateVersions mocks base method.
func (m *MockEC2API) DeleteLaunchTemplateVersions(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*ec2.DeleteLaunchTemplateVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersions", arg0)
	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLaunchTemplateVersions indicates an expected call of DeleteLaunchTemplateVersions.
func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersions), arg0)
}

// DeleteLaunchTemplateVersionsRequest mocks base method.
func (m *MockEC2API) DeleteLaunchTemplateVersionsRequest(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*request.Request, *ec2.DeleteLaunchTemplateVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateVersionsOutput)
	return ret0, ret1
}

// DeleteLaunchTemplateVersionsRequest indicates an expected call of DeleteLaunchTemplateVersionsRequest.
func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersionsRequest), arg0)
}

// DeleteLaunchTemplateVersionsWithContext mocks base method.
func (m *MockEC2API) DeleteLaunchTemplateVersionsWithContext(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLaunchTemplateWithContext mocks base method.
func (m *MockEC2API) DeleteLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteLaunchTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLocalGatewayRoute mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRoute(arg0 *ec2.DeleteLocalGatewayRouteInput) (*ec2.DeleteLocalGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRoute", arg0)
	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLocalGatewayRoute indicates an expected call of DeleteLocalGatewayRoute.
func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRoute), arg0)
}

// DeleteLocalGatewayRouteRequest mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteRequest(arg0 *ec2.DeleteLocalGatewayRouteInput) (*request.Request, *ec2.DeleteLocalGatewayRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteOutput)
	return ret0, ret1
}

// DeleteLocalGatewayRouteRequest indicates an expected call of DeleteLocalGatewayRouteRequest.
func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteRequest), arg0)
}

// DeleteLocalGatewayRouteTable mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTable(arg0 *ec2.DeleteLocalGatewayRouteTableInput) (*ec2.DeleteLocalGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLocalGatewayRouteTable indicates an expected call of DeleteLocalGatewayRouteTable.
func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTable), arg0)
}

// DeleteLocalGatewayRouteTableRequest mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTableRequest(arg0 *ec2.DeleteLocalGatewayRouteTableInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableOutput)
	return ret0, ret1
}

// DeleteLocalGatewayRouteTableRequest indicates an expected call of DeleteLocalGatewayRouteTableRequest.
func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableRequest), arg0)
}

// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation", arg0)
	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation indicates an expected call of DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation.
func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation), arg0)
}

// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
	return ret0, ret1
}

// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest indicates an expected call of DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest.
func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest), arg0)
}

// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLocalGatewayRouteTableVpcAssociation mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociation(arg0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociation", arg0)
	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLocalGatewayRouteTableVpcAssociation indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociation.
func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociation), arg0)
}

// DeleteLocalGatewayRouteTableVpcAssociationRequest mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
	return ret0, ret1
}

// DeleteLocalGatewayRouteTableVpcAssociationRequest indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociationRequest.
func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociationRequest), arg0)
}

// DeleteLocalGatewayRouteTableVpcAssociationWithContext mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociationWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLocalGatewayRouteTableWithContext mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteLocalGatewayRouteWithContext mocks base method.
func (m *MockEC2API) DeleteLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteManagedPrefixList mocks base method.
func (m *MockEC2API) DeleteManagedPrefixList(arg0 *ec2.DeleteManagedPrefixListInput) (*ec2.DeleteManagedPrefixListOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteManagedPrefixList", arg0)
	ret0, _ := ret[0].(*ec2.DeleteManagedPrefixListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteManagedPrefixList indicates an expected call of DeleteManagedPrefixList.
func (mr *MockEC2APIMockRecorder) DeleteManagedPrefixList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).DeleteManagedPrefixList), arg0)
}

// DeleteManagedPrefixListRequest mocks base method.
func (m *MockEC2API) DeleteManagedPrefixListRequest(arg0 *ec2.DeleteManagedPrefixListInput) (*request.Request, *ec2.DeleteManagedPrefixListOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteManagedPrefixListRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteManagedPrefixListOutput)
	return ret0, ret1
}

// DeleteManagedPrefixListRequest indicates an expected call of DeleteManagedPrefixListRequest.
func (mr *MockEC2APIMockRecorder) DeleteManagedPrefixListRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteManagedPrefixListRequest), arg0)
}

// DeleteManagedPrefixListWithContext mocks base method.
func (m *MockEC2API) DeleteManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.DeleteManagedPrefixListInput, arg2 ...request.Option) (*ec2.DeleteManagedPrefixListOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteManagedPrefixListWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteManagedPrefixListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNatGateway mocks base method.
func (m *MockEC2API) DeleteNatGateway(arg0 *ec2.DeleteNatGatewayInput) (*ec2.DeleteNatGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNatGateway", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNatGateway indicates an expected call of DeleteNatGateway.
func (mr *MockEC2APIMockRecorder) DeleteNatGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGateway), arg0)
}

// DeleteNatGatewayRequest mocks base method.
func (m *MockEC2API) DeleteNatGatewayRequest(arg0 *ec2.DeleteNatGatewayInput) (*request.Request, *ec2.DeleteNatGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNatGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNatGatewayOutput)
	return ret0, ret1
}

// DeleteNatGatewayRequest indicates an expected call of DeleteNatGatewayRequest.
func (mr *MockEC2APIMockRecorder) DeleteNatGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGatewayRequest), arg0)
}

// DeleteNatGatewayWithContext mocks base method.
func (m *MockEC2API) DeleteNatGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteNatGatewayInput, arg2 ...request.Option) (*ec2.DeleteNatGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNatGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkAcl mocks base method.
func (m *MockEC2API) DeleteNetworkAcl(arg0 *ec2.DeleteNetworkAclInput) (*ec2.DeleteNetworkAclOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkAcl", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkAcl indicates an expected call of DeleteNetworkAcl.
func (mr *MockEC2APIMockRecorder) DeleteNetworkAcl(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAcl), arg0)
}

// DeleteNetworkAclEntry mocks base method.
func (m *MockEC2API) DeleteNetworkAclEntry(arg0 *ec2.DeleteNetworkAclEntryInput) (*ec2.DeleteNetworkAclEntryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkAclEntry", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkAclEntry indicates an expected call of DeleteNetworkAclEntry.
func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntry(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntry), arg0)
}

// DeleteNetworkAclEntryRequest mocks base method.
func (m *MockEC2API) DeleteNetworkAclEntryRequest(arg0 *ec2.DeleteNetworkAclEntryInput) (*request.Request, *ec2.DeleteNetworkAclEntryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkAclEntryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNetworkAclEntryOutput)
	return ret0, ret1
}

// DeleteNetworkAclEntryRequest indicates an expected call of DeleteNetworkAclEntryRequest.
func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntryRequest), arg0)
}

// DeleteNetworkAclEntryWithContext mocks base method.
func (m *MockEC2API) DeleteNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkAclEntryInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclEntryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkAclEntryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkAclRequest mocks base method.
func (m *MockEC2API) DeleteNetworkAclRequest(arg0 *ec2.DeleteNetworkAclInput) (*request.Request, *ec2.DeleteNetworkAclOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkAclRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNetworkAclOutput)
	return ret0, ret1
}

// DeleteNetworkAclRequest indicates an expected call of DeleteNetworkAclRequest.
func (mr *MockEC2APIMockRecorder) DeleteNetworkAclRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclRequest), arg0)
}

// DeleteNetworkAclWithContext mocks base method.
func (m *MockEC2API) DeleteNetworkAclWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkAclInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkAclWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkInsightsAccessScope mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAccessScope(arg0 *ec2.DeleteNetworkInsightsAccessScopeInput) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScope", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkInsightsAccessScope indicates an expected call of DeleteNetworkInsightsAccessScope.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScope(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScope", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScope), arg0)
}

// DeleteNetworkInsightsAccessScopeAnalysis mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAccessScopeAnalysis(arg0 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysis", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkInsightsAccessScopeAnalysis indicates an expected call of DeleteNetworkInsightsAccessScopeAnalysis.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScopeAnalysis(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeAnalysis", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScopeAnalysis), arg0)
}

// DeleteNetworkInsightsAccessScopeAnalysisRequest mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAccessScopeAnalysisRequest(arg0 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput) (*request.Request, *ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput)
	return ret0, ret1
}

// DeleteNetworkInsightsAccessScopeAnalysisRequest indicates an expected call of DeleteNetworkInsightsAccessScopeAnalysisRequest.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScopeAnalysisRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScopeAnalysisRequest), arg0)
}

// DeleteNetworkInsightsAccessScopeAnalysisWithContext mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAccessScopeAnalysisWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkInsightsAccessScopeRequest mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAccessScopeRequest(arg0 *ec2.DeleteNetworkInsightsAccessScopeInput) (*request.Request, *ec2.DeleteNetworkInsightsAccessScopeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAccessScopeOutput)
	return ret0, ret1
}

// DeleteNetworkInsightsAccessScopeRequest indicates an expected call of DeleteNetworkInsightsAccessScopeRequest.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAccessScopeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAccessScopeRequest), arg0)
}

// DeleteNetworkInsightsAccessScopeWithContext mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAccessScopeWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsAccessScopeInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkInsightsAnalysis mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAnalysis(arg0 *ec2.DeleteNetworkInsightsAnalysisInput) (*ec2.DeleteNetworkInsightsAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysis", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkInsightsAnalysis indicates an expected call of DeleteNetworkInsightsAnalysis.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAnalysis(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAnalysis", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAnalysis), arg0)
}

// DeleteNetworkInsightsAnalysisRequest mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAnalysisRequest(arg0 *ec2.DeleteNetworkInsightsAnalysisInput) (*request.Request, *ec2.DeleteNetworkInsightsAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAnalysisOutput)
	return ret0, ret1
}

// DeleteNetworkInsightsAnalysisRequest indicates an expected call of DeleteNetworkInsightsAnalysisRequest.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsAnalysisRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsAnalysisRequest), arg0)
}

// DeleteNetworkInsightsAnalysisWithContext mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsAnalysisWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsAnalysisInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkInsightsPath mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsPath(arg0 *ec2.DeleteNetworkInsightsPathInput) (*ec2.DeleteNetworkInsightsPathOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsPath", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsPathOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkInsightsPath indicates an expected call of DeleteNetworkInsightsPath.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsPath(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsPath", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsPath), arg0)
}

// DeleteNetworkInsightsPathRequest mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsPathRequest(arg0 *ec2.DeleteNetworkInsightsPathInput) (*request.Request, *ec2.DeleteNetworkInsightsPathOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsPathRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsPathOutput)
	return ret0, ret1
}

// DeleteNetworkInsightsPathRequest indicates an expected call of DeleteNetworkInsightsPathRequest.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInsightsPathRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsPathRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInsightsPathRequest), arg0)
}

// DeleteNetworkInsightsPathWithContext mocks base method.
func (m *MockEC2API) DeleteNetworkInsightsPathWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsPathInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsPathOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkInsightsPathWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsPathOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkInterface mocks base method.
func (m *MockEC2API) DeleteNetworkInterface(arg0 *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInterface", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkInterface indicates an expected call of DeleteNetworkInterface.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInterface(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterface), arg0)
}

// DeleteNetworkInterfacePermission mocks base method.
func (m *MockEC2API) DeleteNetworkInterfacePermission(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*ec2.DeleteNetworkInterfacePermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermission", arg0)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetworkInterfacePermission indicates an expected call of DeleteNetworkInterfacePermission.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermission(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermission), arg0)
}

// DeleteNetworkInterfacePermissionRequest mocks base method.
func (m *MockEC2API) DeleteNetworkInterfacePermissionRequest(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*request.Request, *ec2.DeleteNetworkInterfacePermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNetworkInterfacePermissionOutput)
	return ret0, ret1
}

// DeleteNetworkInterfacePermissionRequest indicates an expected call of DeleteNetworkInterfacePermissionRequest.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermissionRequest), arg0)
}

// DeleteNetworkInterfacePermissionWithContext mocks base method.
func (m *MockEC2API) DeleteNetworkInterfacePermissionWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfacePermissionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkInterfaceRequest mocks base method.
func (m *MockEC2API) DeleteNetworkInterfaceRequest(arg0 *ec2.DeleteNetworkInterfaceInput) (*request.Request, *ec2.DeleteNetworkInterfaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkInterfaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteNetworkInterfaceOutput)
	return ret0, ret1
}

// DeleteNetworkInterfaceRequest indicates an expected call of DeleteNetworkInterfaceRequest.
func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfaceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfaceRequest), arg0)
}

// DeleteNetworkInterfaceWithContext mocks base method.
func (m *MockEC2API) DeleteNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNetworkInterfaceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePlacementGroup mocks base method.
func (m *MockEC2API) DeletePlacementGroup(arg0 *ec2.DeletePlacementGroupInput) (*ec2.DeletePlacementGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePlacementGroup", arg0)
	ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePlacementGroup indicates an expected call of DeletePlacementGroup.
func (mr *MockEC2APIMockRecorder) DeletePlacementGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroup), arg0)
}

// DeletePlacementGroupRequest mocks base method.
func (m *MockEC2API) DeletePlacementGroupRequest(arg0 *ec2.DeletePlacementGroupInput) (*request.Request, *ec2.DeletePlacementGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePlacementGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeletePlacementGroupOutput)
	return ret0, ret1
}

// DeletePlacementGroupRequest indicates an expected call of DeletePlacementGroupRequest.
func (mr *MockEC2APIMockRecorder) DeletePlacementGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroupRequest), arg0)
}

// DeletePlacementGroupWithContext mocks base method.
func (m *MockEC2API) DeletePlacementGroupWithContext(arg0 context.Context, arg1 *ec2.DeletePlacementGroupInput, arg2 ...request.Option) (*ec2.DeletePlacementGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePlacementGroupWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePublicIpv4Pool mocks base method.
func (m *MockEC2API) DeletePublicIpv4Pool(arg0 *ec2.DeletePublicIpv4PoolInput) (*ec2.DeletePublicIpv4PoolOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePublicIpv4Pool", arg0)
	ret0, _ := ret[0].(*ec2.DeletePublicIpv4PoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePublicIpv4Pool indicates an expected call of DeletePublicIpv4Pool.
func (mr *MockEC2APIMockRecorder) DeletePublicIpv4Pool(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicIpv4Pool", reflect.TypeOf((*MockEC2API)(nil).DeletePublicIpv4Pool), arg0)
}

// DeletePublicIpv4PoolRequest mocks base method.
func (m *MockEC2API) DeletePublicIpv4PoolRequest(arg0 *ec2.DeletePublicIpv4PoolInput) (*request.Request, *ec2.DeletePublicIpv4PoolOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePublicIpv4PoolRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeletePublicIpv4PoolOutput)
	return ret0, ret1
}

// DeletePublicIpv4PoolRequest indicates an expected call of DeletePublicIpv4PoolRequest.
func (mr *MockEC2APIMockRecorder) DeletePublicIpv4PoolRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicIpv4PoolRequest", reflect.TypeOf((*MockEC2API)(nil).DeletePublicIpv4PoolRequest), arg0)
}

// DeletePublicIpv4PoolWithContext mocks base method.
func (m *MockEC2API) DeletePublicIpv4PoolWithContext(arg0 context.Context, arg1 *ec2.DeletePublicIpv4PoolInput, arg2 ...request.Option) (*ec2.DeletePublicIpv4PoolOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePublicIpv4PoolWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeletePublicIpv4PoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteQueuedReservedInstances mocks base method.
func (m *MockEC2API) DeleteQueuedReservedInstances(arg0 *ec2.DeleteQueuedReservedInstancesInput) (*ec2.DeleteQueuedReservedInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteQueuedReservedInstances", arg0)
	ret0, _ := ret[0].(*ec2.DeleteQueuedReservedInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteQueuedReservedInstances indicates an expected call of DeleteQueuedReservedInstances.
func (mr *MockEC2APIMockRecorder) DeleteQueuedReservedInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstances), arg0)
}

// DeleteQueuedReservedInstancesRequest mocks base method.
func (m *MockEC2API) DeleteQueuedReservedInstancesRequest(arg0 *ec2.DeleteQueuedReservedInstancesInput) (*request.Request, *ec2.DeleteQueuedReservedInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteQueuedReservedInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteQueuedReservedInstancesOutput)
	return ret0, ret1
}

// DeleteQueuedReservedInstancesRequest indicates an expected call of DeleteQueuedReservedInstancesRequest.
func (mr *MockEC2APIMockRecorder) DeleteQueuedReservedInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstancesRequest), arg0)
}

// DeleteQueuedReservedInstancesWithContext mocks base method.
func (m *MockEC2API) DeleteQueuedReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.DeleteQueuedReservedInstancesInput, arg2 ...request.Option) (*ec2.DeleteQueuedReservedInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteQueuedReservedInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteQueuedReservedInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRoute mocks base method.
func (m *MockEC2API) DeleteRoute(arg0 *ec2.DeleteRouteInput) (*ec2.DeleteRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoute", arg0)
	ret0, _ := ret[0].(*ec2.DeleteRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRoute indicates an expected call of DeleteRoute.
func (mr *MockEC2APIMockRecorder) DeleteRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteRoute), arg0)
}

// DeleteRouteRequest mocks base method.
func (m *MockEC2API) DeleteRouteRequest(arg0 *ec2.DeleteRouteInput) (*request.Request, *ec2.DeleteRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteRouteOutput)
	return ret0, ret1
}

// DeleteRouteRequest indicates an expected call of DeleteRouteRequest.
func (mr *MockEC2APIMockRecorder) DeleteRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteRequest), arg0)
}

// DeleteRouteTable mocks base method.
func (m *MockEC2API) DeleteRouteTable(arg0 *ec2.DeleteRouteTableInput) (*ec2.DeleteRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRouteTable indicates an expected call of DeleteRouteTable.
func (mr *MockEC2APIMockRecorder) DeleteRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTable), arg0)
}

// DeleteRouteTableRequest mocks base method.
func (m *MockEC2API) DeleteRouteTableRequest(arg0 *ec2.DeleteRouteTableInput) (*request.Request, *ec2.DeleteRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteRouteTableOutput)
	return ret0, ret1
}

// DeleteRouteTableRequest indicates an expected call of DeleteRouteTableRequest.
func (mr *MockEC2APIMockRecorder) DeleteRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTableRequest), arg0)
}

// DeleteRouteTableWithContext mocks base method.
func (m *MockEC2API) DeleteRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteRouteTableInput, arg2 ...request.Option) (*ec2.DeleteRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteRouteWithContext mocks base method.
func (m *MockEC2API) DeleteRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteRouteInput, arg2 ...request.Option) (*ec2.DeleteRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteSecurityGroup mocks base method.
func (m *MockEC2API) DeleteSecurityGroup(arg0 *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecurityGroup", arg0)
	ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup.
func (mr *MockEC2APIMockRecorder) DeleteSecurityGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroup), arg0)
}

// DeleteSecurityGroupRequest mocks base method.
func (m *MockEC2API) DeleteSecurityGroupRequest(arg0 *ec2.DeleteSecurityGroupInput) (*request.Request, *ec2.DeleteSecurityGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecurityGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteSecurityGroupOutput)
	return ret0, ret1
}

// DeleteSecurityGroupRequest indicates an expected call of DeleteSecurityGroupRequest.
func (mr *MockEC2APIMockRecorder) DeleteSecurityGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroupRequest), arg0)
}

// DeleteSecurityGroupWithContext mocks base method.
func (m *MockEC2API) DeleteSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.DeleteSecurityGroupInput, arg2 ...request.Option) (*ec2.DeleteSecurityGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSecurityGroupWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteSnapshot mocks base method.
func (m *MockEC2API) DeleteSnapshot(arg0 *ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSnapshot", arg0)
	ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSnapshot indicates an expected call of DeleteSnapshot.
func (mr *MockEC2APIMockRecorder) DeleteSnapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshot), arg0)
}

// DeleteSnapshotRequest mocks base method.
func (m *MockEC2API) DeleteSnapshotRequest(arg0 *ec2.DeleteSnapshotInput) (*request.Request, *ec2.DeleteSnapshotOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteSnapshotOutput)
	return ret0, ret1
}

// DeleteSnapshotRequest indicates an expected call of DeleteSnapshotRequest.
func (mr *MockEC2APIMockRecorder) DeleteSnapshotRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshotRequest), arg0)
}

// DeleteSnapshotWithContext mocks base method.
func (m *MockEC2API) DeleteSnapshotWithContext(arg0 context.Context, arg1 *ec2.DeleteSnapshotInput, arg2 ...request.Option) (*ec2.DeleteSnapshotOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteSpotDatafeedSubscription mocks base method.
func (m *MockEC2API) DeleteSpotDatafeedSubscription(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscription", arg0)
	ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSpotDatafeedSubscription indicates an expected call of DeleteSpotDatafeedSubscription.
func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscription(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscription), arg0)
}

// DeleteSpotDatafeedSubscriptionRequest mocks base method.
func (m *MockEC2API) DeleteSpotDatafeedSubscriptionRequest(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteSpotDatafeedSubscriptionOutput)
	return ret0, ret1
}

// DeleteSpotDatafeedSubscriptionRequest indicates an expected call of DeleteSpotDatafeedSubscriptionRequest.
func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionRequest), arg0)
}

// DeleteSpotDatafeedSubscriptionWithContext mocks base method.
func (m *MockEC2API) DeleteSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DeleteSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteSubnet mocks base method.
func (m *MockEC2API) DeleteSubnet(arg0 *ec2.DeleteSubnetInput) (*ec2.DeleteSubnetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubnet", arg0)
	ret0, _ := ret[0].(*ec2.DeleteSubnetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSubnet indicates an expected call of DeleteSubnet.
func (mr *MockEC2APIMockRecorder) DeleteSubnet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnet), arg0)
}

// DeleteSubnetCidrReservation mocks base method.
func (m *MockEC2API) DeleteSubnetCidrReservation(arg0 *ec2.DeleteSubnetCidrReservationInput) (*ec2.DeleteSubnetCidrReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubnetCidrReservation", arg0)
	ret0, _ := ret[0].(*ec2.DeleteSubnetCidrReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSubnetCidrReservation indicates an expected call of DeleteSubnetCidrReservation.
func (mr *MockEC2APIMockRecorder) DeleteSubnetCidrReservation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetCidrReservation", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetCidrReservation), arg0)
}

// DeleteSubnetCidrReservationRequest mocks base method.
func (m *MockEC2API) DeleteSubnetCidrReservationRequest(arg0 *ec2.DeleteSubnetCidrReservationInput) (*request.Request, *ec2.DeleteSubnetCidrReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubnetCidrReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteSubnetCidrReservationOutput)
	return ret0, ret1
}

// DeleteSubnetCidrReservationRequest indicates an expected call of DeleteSubnetCidrReservationRequest.
func (mr *MockEC2APIMockRecorder) DeleteSubnetCidrReservationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetCidrReservationRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetCidrReservationRequest), arg0)
}

// DeleteSubnetCidrReservationWithContext mocks base method.
func (m *MockEC2API) DeleteSubnetCidrReservationWithContext(arg0 context.Context, arg1 *ec2.DeleteSubnetCidrReservationInput, arg2 ...request.Option) (*ec2.DeleteSubnetCidrReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSubnetCidrReservationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteSubnetCidrReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteSubnetRequest mocks base method.
func (m *MockEC2API) DeleteSubnetRequest(arg0 *ec2.DeleteSubnetInput) (*request.Request, *ec2.DeleteSubnetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubnetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteSubnetOutput)
	return ret0, ret1
}

// DeleteSubnetRequest indicates an expected call of DeleteSubnetRequest.
func (mr *MockEC2APIMockRecorder) DeleteSubnetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetRequest), arg0)
}

// DeleteSubnetWithContext mocks base method.
func (m *MockEC2API) DeleteSubnetWithContext(arg0 context.Context, arg1 *ec2.DeleteSubnetInput, arg2 ...request.Option) (*ec2.DeleteSubnetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSubnetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteSubnetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTags mocks base method.
func (m *MockEC2API) DeleteTags(arg0 *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTags", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTags indicates an expected call of DeleteTags.
func (mr *MockEC2APIMockRecorder) DeleteTags(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockEC2API)(nil).DeleteTags), arg0)
}

// DeleteTagsRequest mocks base method.
func (m *MockEC2API) DeleteTagsRequest(arg0 *ec2.DeleteTagsInput) (*request.Request, *ec2.DeleteTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTagsOutput)
	return ret0, ret1
}

// DeleteTagsRequest indicates an expected call of DeleteTagsRequest.
func (mr *MockEC2APIMockRecorder) DeleteTagsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTagsRequest), arg0)
}

// DeleteTagsWithContext mocks base method.
func (m *MockEC2API) DeleteTagsWithContext(arg0 context.Context, arg1 *ec2.DeleteTagsInput, arg2 ...request.Option) (*ec2.DeleteTagsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTagsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTrafficMirrorFilter mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorFilter(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*ec2.DeleteTrafficMirrorFilterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilter", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrafficMirrorFilter indicates an expected call of DeleteTrafficMirrorFilter.
func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilter(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilter), arg0)
}

// DeleteTrafficMirrorFilterRequest mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorFilterRequest(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterOutput)
	return ret0, ret1
}

// DeleteTrafficMirrorFilterRequest indicates an expected call of DeleteTrafficMirrorFilterRequest.
func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRequest), arg0)
}

// DeleteTrafficMirrorFilterRule mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorFilterRule(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRule", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrafficMirrorFilterRule indicates an expected call of DeleteTrafficMirrorFilterRule.
func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRule), arg0)
}

// DeleteTrafficMirrorFilterRuleRequest mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorFilterRuleRequest(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterRuleOutput)
	return ret0, ret1
}

// DeleteTrafficMirrorFilterRuleRequest indicates an expected call of DeleteTrafficMirrorFilterRuleRequest.
func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleRequest), arg0)
}

// DeleteTrafficMirrorFilterRuleWithContext mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTrafficMirrorFilterWithContext mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorFilterWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTrafficMirrorSession mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorSession(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*ec2.DeleteTrafficMirrorSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorSession", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrafficMirrorSession indicates an expected call of DeleteTrafficMirrorSession.
func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSession(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSession), arg0)
}

// DeleteTrafficMirrorSessionRequest mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorSessionRequest(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*request.Request, *ec2.DeleteTrafficMirrorSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorSessionOutput)
	return ret0, ret1
}

// DeleteTrafficMirrorSessionRequest indicates an expected call of DeleteTrafficMirrorSessionRequest.
func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSessionRequest), arg0)
}

// DeleteTrafficMirrorSessionWithContext mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTrafficMirrorTarget mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorTarget(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*ec2.DeleteTrafficMirrorTargetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorTarget", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTrafficMirrorTarget indicates an expected call of DeleteTrafficMirrorTarget.
func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTarget(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTarget), arg0)
}

// DeleteTrafficMirrorTargetRequest mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorTargetRequest(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*request.Request, *ec2.DeleteTrafficMirrorTargetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorTargetOutput)
	return ret0, ret1
}

// DeleteTrafficMirrorTargetRequest indicates an expected call of DeleteTrafficMirrorTargetRequest.
func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTargetRequest), arg0)
}

// DeleteTrafficMirrorTargetWithContext mocks base method.
func (m *MockEC2API) DeleteTrafficMirrorTargetWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorTargetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGateway mocks base method.
func (m *MockEC2API) DeleteTransitGateway(arg0 *ec2.DeleteTransitGatewayInput) (*ec2.DeleteTransitGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGateway", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGateway indicates an expected call of DeleteTransitGateway.
func (mr *MockEC2APIMockRecorder) DeleteTransitGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGateway), arg0)
}

// DeleteTransitGatewayConnect mocks base method.
func (m *MockEC2API) DeleteTransitGatewayConnect(arg0 *ec2.DeleteTransitGatewayConnectInput) (*ec2.DeleteTransitGatewayConnectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnect", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayConnect indicates an expected call of DeleteTransitGatewayConnect.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnect(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnect", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnect), arg0)
}

// DeleteTransitGatewayConnectPeer mocks base method.
func (m *MockEC2API) DeleteTransitGatewayConnectPeer(arg0 *ec2.DeleteTransitGatewayConnectPeerInput) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeer", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectPeerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayConnectPeer indicates an expected call of DeleteTransitGatewayConnectPeer.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectPeer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectPeer", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectPeer), arg0)
}

// DeleteTransitGatewayConnectPeerRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayConnectPeerRequest(arg0 *ec2.DeleteTransitGatewayConnectPeerInput) (*request.Request, *ec2.DeleteTransitGatewayConnectPeerOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeerRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayConnectPeerOutput)
	return ret0, ret1
}

// DeleteTransitGatewayConnectPeerRequest indicates an expected call of DeleteTransitGatewayConnectPeerRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectPeerRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectPeerRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectPeerRequest), arg0)
}

// DeleteTransitGatewayConnectPeerWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayConnectPeerWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayConnectPeerInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayConnectPeerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectPeerWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectPeerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayConnectRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayConnectRequest(arg0 *ec2.DeleteTransitGatewayConnectInput) (*request.Request, *ec2.DeleteTransitGatewayConnectOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayConnectOutput)
	return ret0, ret1
}

// DeleteTransitGatewayConnectRequest indicates an expected call of DeleteTransitGatewayConnectRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayConnectRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayConnectRequest), arg0)
}

// DeleteTransitGatewayConnectWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayConnectWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayConnectInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayConnectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayConnectWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayConnectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayMulticastDomain mocks base method.
func (m *MockEC2API) DeleteTransitGatewayMulticastDomain(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomain", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayMulticastDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayMulticastDomain indicates an expected call of DeleteTransitGatewayMulticastDomain.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomain), arg0)
}

// DeleteTransitGatewayMulticastDomainRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayMulticastDomainRequest(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DeleteTransitGatewayMulticastDomainOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomainRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayMulticastDomainOutput)
	return ret0, ret1
}

// DeleteTransitGatewayMulticastDomainRequest indicates an expected call of DeleteTransitGatewayMulticastDomainRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomainRequest), arg0)
}

// DeleteTransitGatewayMulticastDomainWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomainWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayMulticastDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayPeeringAttachment mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPeeringAttachment(arg0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachment", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayPeeringAttachment indicates an expected call of DeleteTransitGatewayPeeringAttachment.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachment), arg0)
}

// DeleteTransitGatewayPeeringAttachmentRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPeeringAttachmentRequest(arg0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayPeeringAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
	return ret0, ret1
}

// DeleteTransitGatewayPeeringAttachmentRequest indicates an expected call of DeleteTransitGatewayPeeringAttachmentRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachmentRequest), arg0)
}

// DeleteTransitGatewayPeeringAttachmentWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayPolicyTable mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPolicyTable(arg0 *ec2.DeleteTransitGatewayPolicyTableInput) (*ec2.DeleteTransitGatewayPolicyTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTable", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPolicyTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayPolicyTable indicates an expected call of DeleteTransitGatewayPolicyTable.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPolicyTable), arg0)
}

// DeleteTransitGatewayPolicyTableRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPolicyTableRequest(arg0 *ec2.DeleteTransitGatewayPolicyTableInput) (*request.Request, *ec2.DeleteTransitGatewayPolicyTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPolicyTableOutput)
	return ret0, ret1
}

// DeleteTransitGatewayPolicyTableRequest indicates an expected call of DeleteTransitGatewayPolicyTableRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPolicyTableRequest), arg0)
}

// DeleteTransitGatewayPolicyTableWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPolicyTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPolicyTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayPrefixListReference mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPrefixListReference(arg0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReference", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayPrefixListReference indicates an expected call of DeleteTransitGatewayPrefixListReference.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPrefixListReference), arg0)
}

// DeleteTransitGatewayPrefixListReferenceRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPrefixListReferenceRequest(arg0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.DeleteTransitGatewayPrefixListReferenceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReferenceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
	return ret0, ret1
}

// DeleteTransitGatewayPrefixListReferenceRequest indicates an expected call of DeleteTransitGatewayPrefixListReferenceRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPrefixListReferenceRequest), arg0)
}

// DeleteTransitGatewayPrefixListReferenceWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReferenceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRequest(arg0 *ec2.DeleteTransitGatewayInput) (*request.Request, *ec2.DeleteTransitGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayOutput)
	return ret0, ret1
}

// DeleteTransitGatewayRequest indicates an expected call of DeleteTransitGatewayRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRequest), arg0)
}

// DeleteTransitGatewayRoute mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRoute(arg0 *ec2.DeleteTransitGatewayRouteInput) (*ec2.DeleteTransitGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRoute", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayRoute indicates an expected call of DeleteTransitGatewayRoute.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRoute), arg0)
}

// DeleteTransitGatewayRouteRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRouteRequest(arg0 *ec2.DeleteTransitGatewayRouteInput) (*request.Request, *ec2.DeleteTransitGatewayRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteOutput)
	return ret0, ret1
}

// DeleteTransitGatewayRouteRequest indicates an expected call of DeleteTransitGatewayRouteRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteRequest), arg0)
}

// DeleteTransitGatewayRouteTable mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRouteTable(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*ec2.DeleteTransitGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayRouteTable indicates an expected call of DeleteTransitGatewayRouteTable.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTable), arg0)
}

// DeleteTransitGatewayRouteTableAnnouncement mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRouteTableAnnouncement(arg0 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncement", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayRouteTableAnnouncement indicates an expected call of DeleteTransitGatewayRouteTableAnnouncement.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableAnnouncement(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableAnnouncement", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableAnnouncement), arg0)
}

// DeleteTransitGatewayRouteTableAnnouncementRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRouteTableAnnouncementRequest(arg0 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableAnnouncementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput)
	return ret0, ret1
}

// DeleteTransitGatewayRouteTableAnnouncementRequest indicates an expected call of DeleteTransitGatewayRouteTableAnnouncementRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableAnnouncementRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableAnnouncementRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableAnnouncementRequest), arg0)
}

// DeleteTransitGatewayRouteTableAnnouncementWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRouteTableAnnouncementWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncementWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayRouteTableRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRouteTableRequest(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteTableOutput)
	return ret0, ret1
}

// DeleteTransitGatewayRouteTableRequest indicates an expected call of DeleteTransitGatewayRouteTableRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableRequest), arg0)
}

// DeleteTransitGatewayRouteTableWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayRouteWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayVpcAttachment mocks base method.
func (m *MockEC2API) DeleteTransitGatewayVpcAttachment(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachment", arg0)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTransitGatewayVpcAttachment indicates an expected call of DeleteTransitGatewayVpcAttachment.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachment), arg0)
}

// DeleteTransitGatewayVpcAttachmentRequest mocks base method.
func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentRequest(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayVpcAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
	return ret0, ret1
}

// DeleteTransitGatewayVpcAttachmentRequest indicates an expected call of DeleteTransitGatewayVpcAttachmentRequest.
func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentRequest), arg0)
}

// DeleteTransitGatewayVpcAttachmentWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTransitGatewayWithContext mocks base method.
func (m *MockEC2API) DeleteTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTransitGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVerifiedAccessEndpoint mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessEndpoint(arg0 *ec2.DeleteVerifiedAccessEndpointInput) (*ec2.DeleteVerifiedAccessEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVerifiedAccessEndpoint indicates an expected call of DeleteVerifiedAccessEndpoint.
func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessEndpoint), arg0)
}

// DeleteVerifiedAccessEndpointRequest mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessEndpointRequest(arg0 *ec2.DeleteVerifiedAccessEndpointInput) (*request.Request, *ec2.DeleteVerifiedAccessEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessEndpointOutput)
	return ret0, ret1
}

// DeleteVerifiedAccessEndpointRequest indicates an expected call of DeleteVerifiedAccessEndpointRequest.
func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessEndpointRequest), arg0)
}

// DeleteVerifiedAccessEndpointWithContext mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVerifiedAccessGroup mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessGroup(arg0 *ec2.DeleteVerifiedAccessGroupInput) (*ec2.DeleteVerifiedAccessGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroup", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVerifiedAccessGroup indicates an expected call of DeleteVerifiedAccessGroup.
func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessGroup", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessGroup), arg0)
}

// DeleteVerifiedAccessGroupRequest mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessGroupRequest(arg0 *ec2.DeleteVerifiedAccessGroupInput) (*request.Request, *ec2.DeleteVerifiedAccessGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessGroupOutput)
	return ret0, ret1
}

// DeleteVerifiedAccessGroupRequest indicates an expected call of DeleteVerifiedAccessGroupRequest.
func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessGroupRequest), arg0)
}

// DeleteVerifiedAccessGroupWithContext mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroupWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVerifiedAccessInstance mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessInstance(arg0 *ec2.DeleteVerifiedAccessInstanceInput) (*ec2.DeleteVerifiedAccessInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstance", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVerifiedAccessInstance indicates an expected call of DeleteVerifiedAccessInstance.
func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessInstance", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessInstance), arg0)
}

// DeleteVerifiedAccessInstanceRequest mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessInstanceRequest(arg0 *ec2.DeleteVerifiedAccessInstanceInput) (*request.Request, *ec2.DeleteVerifiedAccessInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessInstanceOutput)
	return ret0, ret1
}

// DeleteVerifiedAccessInstanceRequest indicates an expected call of DeleteVerifiedAccessInstanceRequest.
func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessInstanceRequest), arg0)
}

// DeleteVerifiedAccessInstanceWithContext mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVerifiedAccessTrustProvider mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessTrustProvider(arg0 *ec2.DeleteVerifiedAccessTrustProviderInput) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProvider", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVerifiedAccessTrustProvider indicates an expected call of DeleteVerifiedAccessTrustProvider.
func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessTrustProvider), arg0)
}

// DeleteVerifiedAccessTrustProviderRequest mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessTrustProviderRequest(arg0 *ec2.DeleteVerifiedAccessTrustProviderInput) (*request.Request, *ec2.DeleteVerifiedAccessTrustProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessTrustProviderOutput)
	return ret0, ret1
}

// DeleteVerifiedAccessTrustProviderRequest indicates an expected call of DeleteVerifiedAccessTrustProviderRequest.
func (mr *MockEC2APIMockRecorder) DeleteVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVerifiedAccessTrustProviderRequest), arg0)
}

// DeleteVerifiedAccessTrustProviderWithContext mocks base method.
func (m *MockEC2API) DeleteVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProviderWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVolume mocks base method.
func (m *MockEC2API) DeleteVolume(arg0 *ec2.DeleteVolumeInput) (*ec2.DeleteVolumeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVolume", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVolumeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVolume indicates an expected call of DeleteVolume.
func (mr *MockEC2APIMockRecorder) DeleteVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockEC2API)(nil).DeleteVolume), arg0)
}

// DeleteVolumeRequest mocks base method.
func (m *MockEC2API) DeleteVolumeRequest(arg0 *ec2.DeleteVolumeInput) (*request.Request, *ec2.DeleteVolumeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVolumeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVolumeOutput)
	return ret0, ret1
}

// DeleteVolumeRequest indicates an expected call of DeleteVolumeRequest.
func (mr *MockEC2APIMockRecorder) DeleteVolumeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVolumeRequest), arg0)
}

// DeleteVolumeWithContext mocks base method.
func (m *MockEC2API) DeleteVolumeWithContext(arg0 context.Context, arg1 *ec2.DeleteVolumeInput, arg2 ...request.Option) (*ec2.DeleteVolumeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVolumeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVolumeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpc mocks base method.
func (m *MockEC2API) DeleteVpc(arg0 *ec2.DeleteVpcInput) (*ec2.DeleteVpcOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpc", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpc indicates an expected call of DeleteVpc.
func (mr *MockEC2APIMockRecorder) DeleteVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockEC2API)(nil).DeleteVpc), arg0)
}

// DeleteVpcEndpointConnectionNotifications mocks base method.
func (m *MockEC2API) DeleteVpcEndpointConnectionNotifications(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotifications", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpcEndpointConnectionNotifications indicates an expected call of DeleteVpcEndpointConnectionNotifications.
func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotifications), arg0)
}

// DeleteVpcEndpointConnectionNotificationsRequest mocks base method.
func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DeleteVpcEndpointConnectionNotificationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
	return ret0, ret1
}

// DeleteVpcEndpointConnectionNotificationsRequest indicates an expected call of DeleteVpcEndpointConnectionNotificationsRequest.
func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsRequest), arg0)
}

// DeleteVpcEndpointConnectionNotificationsWithContext mocks base method.
func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpcEndpointServiceConfigurations mocks base method.
func (m *MockEC2API) DeleteVpcEndpointServiceConfigurations(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurations", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpcEndpointServiceConfigurations indicates an expected call of DeleteVpcEndpointServiceConfigurations.
func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurations), arg0)
}

// DeleteVpcEndpointServiceConfigurationsRequest mocks base method.
func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DeleteVpcEndpointServiceConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
	return ret0, ret1
}

// DeleteVpcEndpointServiceConfigurationsRequest indicates an expected call of DeleteVpcEndpointServiceConfigurationsRequest.
func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsRequest), arg0)
}

// DeleteVpcEndpointServiceConfigurationsWithContext mocks base method.
func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpcEndpoints mocks base method.
func (m *MockEC2API) DeleteVpcEndpoints(arg0 *ec2.DeleteVpcEndpointsInput) (*ec2.DeleteVpcEndpointsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcEndpoints", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpcEndpoints indicates an expected call of DeleteVpcEndpoints.
func (mr *MockEC2APIMockRecorder) DeleteVpcEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpoints), arg0)
}

// DeleteVpcEndpointsRequest mocks base method.
func (m *MockEC2API) DeleteVpcEndpointsRequest(arg0 *ec2.DeleteVpcEndpointsInput) (*request.Request, *ec2.DeleteVpcEndpointsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcEndpointsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVpcEndpointsOutput)
	return ret0, ret1
}

// DeleteVpcEndpointsRequest indicates an expected call of DeleteVpcEndpointsRequest.
func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointsRequest), arg0)
}

// DeleteVpcEndpointsWithContext mocks base method.
func (m *MockEC2API) DeleteVpcEndpointsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpcEndpointsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpcPeeringConnection mocks base method.
func (m *MockEC2API) DeleteVpcPeeringConnection(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*ec2.DeleteVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnection", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpcPeeringConnection indicates an expected call of DeleteVpcPeeringConnection.
func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnection), arg0)
}

// DeleteVpcPeeringConnectionRequest mocks base method.
func (m *MockEC2API) DeleteVpcPeeringConnectionRequest(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*request.Request, *ec2.DeleteVpcPeeringConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVpcPeeringConnectionOutput)
	return ret0, ret1
}

// DeleteVpcPeeringConnectionRequest indicates an expected call of DeleteVpcPeeringConnectionRequest.
func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnectionRequest), arg0)
}

// DeleteVpcPeeringConnectionWithContext mocks base method.
func (m *MockEC2API) DeleteVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpcRequest mocks base method.
func (m *MockEC2API) DeleteVpcRequest(arg0 *ec2.DeleteVpcInput) (*request.Request, *ec2.DeleteVpcOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpcRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVpcOutput)
	return ret0, ret1
}

// DeleteVpcRequest indicates an expected call of DeleteVpcRequest.
func (mr *MockEC2APIMockRecorder) DeleteVpcRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcRequest), arg0)
}

// DeleteVpcWithContext mocks base method.
func (m *MockEC2API) DeleteVpcWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcInput, arg2 ...request.Option) (*ec2.DeleteVpcOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpcWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpnConnection mocks base method.
func (m *MockEC2API) DeleteVpnConnection(arg0 *ec2.DeleteVpnConnectionInput) (*ec2.DeleteVpnConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpnConnection", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpnConnection indicates an expected call of DeleteVpnConnection.
func (mr *MockEC2APIMockRecorder) DeleteVpnConnection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnection), arg0)
}

// DeleteVpnConnectionRequest mocks base method.
func (m *MockEC2API) DeleteVpnConnectionRequest(arg0 *ec2.DeleteVpnConnectionInput) (*request.Request, *ec2.DeleteVpnConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpnConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVpnConnectionOutput)
	return ret0, ret1
}

// DeleteVpnConnectionRequest indicates an expected call of DeleteVpnConnectionRequest.
func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRequest), arg0)
}

// DeleteVpnConnectionRoute mocks base method.
func (m *MockEC2API) DeleteVpnConnectionRoute(arg0 *ec2.DeleteVpnConnectionRouteInput) (*ec2.DeleteVpnConnectionRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpnConnectionRoute", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpnConnectionRoute indicates an expected call of DeleteVpnConnectionRoute.
func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRoute), arg0)
}

// DeleteVpnConnectionRouteRequest mocks base method.
func (m *MockEC2API) DeleteVpnConnectionRouteRequest(arg0 *ec2.DeleteVpnConnectionRouteInput) (*request.Request, *ec2.DeleteVpnConnectionRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVpnConnectionRouteOutput)
	return ret0, ret1
}

// DeleteVpnConnectionRouteRequest indicates an expected call of DeleteVpnConnectionRouteRequest.
func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRouteRequest), arg0)
}

// DeleteVpnConnectionRouteWithContext mocks base method.
func (m *MockEC2API) DeleteVpnConnectionRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpnConnectionWithContext mocks base method.
func (m *MockEC2API) DeleteVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpnConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVpnGateway mocks base method.
func (m *MockEC2API) DeleteVpnGateway(arg0 *ec2.DeleteVpnGatewayInput) (*ec2.DeleteVpnGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpnGateway", arg0)
	ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpnGateway indicates an expected call of DeleteVpnGateway.
func (mr *MockEC2APIMockRecorder) DeleteVpnGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGateway), arg0)
}

// DeleteVpnGatewayRequest mocks base method.
func (m *MockEC2API) DeleteVpnGatewayRequest(arg0 *ec2.DeleteVpnGatewayInput) (*request.Request, *ec2.DeleteVpnGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpnGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeleteVpnGatewayOutput)
	return ret0, ret1
}

// DeleteVpnGatewayRequest indicates an expected call of DeleteVpnGatewayRequest.
func (mr *MockEC2APIMockRecorder) DeleteVpnGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGatewayRequest), arg0)
}

// DeleteVpnGatewayWithContext mocks base method.
func (m *MockEC2API) DeleteVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnGatewayInput, arg2 ...request.Option) (*ec2.DeleteVpnGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteVpnGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeprovisionByoipCidr mocks base method.
func (m *MockEC2API) DeprovisionByoipCidr(arg0 *ec2.DeprovisionByoipCidrInput) (*ec2.DeprovisionByoipCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeprovisionByoipCidr", arg0)
	ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeprovisionByoipCidr indicates an expected call of DeprovisionByoipCidr.
func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidr), arg0)
}

// DeprovisionByoipCidrRequest mocks base method.
func (m *MockEC2API) DeprovisionByoipCidrRequest(arg0 *ec2.DeprovisionByoipCidrInput) (*request.Request, *ec2.DeprovisionByoipCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeprovisionByoipCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeprovisionByoipCidrOutput)
	return ret0, ret1
}

// DeprovisionByoipCidrRequest indicates an expected call of DeprovisionByoipCidrRequest.
func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidrRequest), arg0)
}

// DeprovisionByoipCidrWithContext mocks base method.
func (m *MockEC2API) DeprovisionByoipCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionByoipCidrInput, arg2 ...request.Option) (*ec2.DeprovisionByoipCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeprovisionByoipCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeprovisionIpamByoasn mocks base method.
func (m *MockEC2API) DeprovisionIpamByoasn(arg0 *ec2.DeprovisionIpamByoasnInput) (*ec2.DeprovisionIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeprovisionIpamByoasn", arg0)
	ret0, _ := ret[0].(*ec2.DeprovisionIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeprovisionIpamByoasn indicates an expected call of DeprovisionIpamByoasn.
func (mr *MockEC2APIMockRecorder) DeprovisionIpamByoasn(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamByoasn), arg0)
}

// DeprovisionIpamByoasnRequest mocks base method.
func (m *MockEC2API) DeprovisionIpamByoasnRequest(arg0 *ec2.DeprovisionIpamByoasnInput) (*request.Request, *ec2.DeprovisionIpamByoasnOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeprovisionIpamByoasnRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeprovisionIpamByoasnOutput)
	return ret0, ret1
}

// DeprovisionIpamByoasnRequest indicates an expected call of DeprovisionIpamByoasnRequest.
func (mr *MockEC2APIMockRecorder) DeprovisionIpamByoasnRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamByoasnRequest), arg0)
}

// DeprovisionIpamByoasnWithContext mocks base method.
func (m *MockEC2API) DeprovisionIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DeprovisionIpamByoasnInput, arg2 ...request.Option) (*ec2.DeprovisionIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeprovisionIpamByoasnWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeprovisionIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeprovisionIpamPoolCidr mocks base method.
func (m *MockEC2API) DeprovisionIpamPoolCidr(arg0 *ec2.DeprovisionIpamPoolCidrInput) (*ec2.DeprovisionIpamPoolCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidr", arg0)
	ret0, _ := ret[0].(*ec2.DeprovisionIpamPoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeprovisionIpamPoolCidr indicates an expected call of DeprovisionIpamPoolCidr.
func (mr *MockEC2APIMockRecorder) DeprovisionIpamPoolCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamPoolCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamPoolCidr), arg0)
}

// DeprovisionIpamPoolCidrRequest mocks base method.
func (m *MockEC2API) DeprovisionIpamPoolCidrRequest(arg0 *ec2.DeprovisionIpamPoolCidrInput) (*request.Request, *ec2.DeprovisionIpamPoolCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeprovisionIpamPoolCidrOutput)
	return ret0, ret1
}

// DeprovisionIpamPoolCidrRequest indicates an expected call of DeprovisionIpamPoolCidrRequest.
func (mr *MockEC2APIMockRecorder) DeprovisionIpamPoolCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamPoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionIpamPoolCidrRequest), arg0)
}

// DeprovisionIpamPoolCidrWithContext mocks base method.
func (m *MockEC2API) DeprovisionIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionIpamPoolCidrInput, arg2 ...request.Option) (*ec2.DeprovisionIpamPoolCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeprovisionIpamPoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeprovisionPublicIpv4PoolCidr mocks base method.
func (m *MockEC2API) DeprovisionPublicIpv4PoolCidr(arg0 *ec2.DeprovisionPublicIpv4PoolCidrInput) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidr", arg0)
	ret0, _ := ret[0].(*ec2.DeprovisionPublicIpv4PoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeprovisionPublicIpv4PoolCidr indicates an expected call of DeprovisionPublicIpv4PoolCidr.
func (mr *MockEC2APIMockRecorder) DeprovisionPublicIpv4PoolCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionPublicIpv4PoolCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionPublicIpv4PoolCidr), arg0)
}

// DeprovisionPublicIpv4PoolCidrRequest mocks base method.
func (m *MockEC2API) DeprovisionPublicIpv4PoolCidrRequest(arg0 *ec2.DeprovisionPublicIpv4PoolCidrInput) (*request.Request, *ec2.DeprovisionPublicIpv4PoolCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeprovisionPublicIpv4PoolCidrOutput)
	return ret0, ret1
}

// DeprovisionPublicIpv4PoolCidrRequest indicates an expected call of DeprovisionPublicIpv4PoolCidrRequest.
func (mr *MockEC2APIMockRecorder) DeprovisionPublicIpv4PoolCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionPublicIpv4PoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionPublicIpv4PoolCidrRequest), arg0)
}

// DeprovisionPublicIpv4PoolCidrWithContext mocks base method.
func (m *MockEC2API) DeprovisionPublicIpv4PoolCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionPublicIpv4PoolCidrInput, arg2 ...request.Option) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeprovisionPublicIpv4PoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterImage mocks base method.
func (m *MockEC2API) DeregisterImage(arg0 *ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterImage", arg0)
	ret0, _ := ret[0].(*ec2.DeregisterImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeregisterImage indicates an expected call of DeregisterImage.
func (mr *MockEC2APIMockRecorder) DeregisterImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImage", reflect.TypeOf((*MockEC2API)(nil).DeregisterImage), arg0)
}

// DeregisterImageRequest mocks base method.
func (m *MockEC2API) DeregisterImageRequest(arg0 *ec2.DeregisterImageInput) (*request.Request, *ec2.DeregisterImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeregisterImageOutput)
	return ret0, ret1
}

// DeregisterImageRequest indicates an expected call of DeregisterImageRequest.
func (mr *MockEC2APIMockRecorder) DeregisterImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterImageRequest), arg0)
}

// DeregisterImageWithContext mocks base method.
func (m *MockEC2API) DeregisterImageWithContext(arg0 context.Context, arg1 *ec2.DeregisterImageInput, arg2 ...request.Option) (*ec2.DeregisterImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeregisterImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterInstanceEventNotificationAttributes mocks base method.
func (m *MockEC2API) DeregisterInstanceEventNotificationAttributes(arg0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributes", arg0)
	ret0, _ := ret[0].(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeregisterInstanceEventNotificationAttributes indicates an expected call of DeregisterInstanceEventNotificationAttributes.
func (mr *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributes), arg0)
}

// DeregisterInstanceEventNotificationAttributesRequest mocks base method.
func (m *MockEC2API) DeregisterInstanceEventNotificationAttributesRequest(arg0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DeregisterInstanceEventNotificationAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
	return ret0, ret1
}

// DeregisterInstanceEventNotificationAttributesRequest indicates an expected call of DeregisterInstanceEventNotificationAttributesRequest.
func (mr *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributesRequest), arg0)
}

// DeregisterInstanceEventNotificationAttributesWithContext mocks base method.
func (m *MockEC2API) DeregisterInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.DeregisterInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeregisterInstanceEventNotificationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterTransitGatewayMulticastGroupMembers mocks base method.
func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembers(arg0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembers", arg0)
	ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeregisterTransitGatewayMulticastGroupMembers indicates an expected call of DeregisterTransitGatewayMulticastGroupMembers.
func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembers), arg0)
}

// DeregisterTransitGatewayMulticastGroupMembersRequest mocks base method.
func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
	return ret0, ret1
}

// DeregisterTransitGatewayMulticastGroupMembersRequest indicates an expected call of DeregisterTransitGatewayMulticastGroupMembersRequest.
func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembersRequest), arg0)
}

// DeregisterTransitGatewayMulticastGroupMembersWithContext mocks base method.
func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembersWithContext(arg0 context.Context, arg1 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, arg2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembersWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterTransitGatewayMulticastGroupSources mocks base method.
func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSources(arg0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSources", arg0)
	ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeregisterTransitGatewayMulticastGroupSources indicates an expected call of DeregisterTransitGatewayMulticastGroupSources.
func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSources), arg0)
}

// DeregisterTransitGatewayMulticastGroupSourcesRequest mocks base method.
func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSourcesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
	return ret0, ret1
}

// DeregisterTransitGatewayMulticastGroupSourcesRequest indicates an expected call of DeregisterTransitGatewayMulticastGroupSourcesRequest.
func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSourcesRequest), arg0)
}

// DeregisterTransitGatewayMulticastGroupSourcesWithContext mocks base method.
func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSourcesWithContext(arg0 context.Context, arg1 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, arg2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSourcesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAccountAttributes mocks base method.
func (m *MockEC2API) DescribeAccountAttributes(arg0 *ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountAttributes", arg0)
	ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeAccountAttributes indicates an expected call of DescribeAccountAttributes.
func (mr *MockEC2APIMockRecorder) DescribeAccountAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributes), arg0)
}

// DescribeAccountAttributesRequest mocks base method.
func (m *MockEC2API) DescribeAccountAttributesRequest(arg0 *ec2.DescribeAccountAttributesInput) (*request.Request, *ec2.DescribeAccountAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAccountAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeAccountAttributesOutput)
	return ret0, ret1
}

// DescribeAccountAttributesRequest indicates an expected call of DescribeAccountAttributesRequest.
func (mr *MockEC2APIMockRecorder) DescribeAccountAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributesRequest), arg0)
}

// DescribeAccountAttributesWithContext mocks base method.
func (m *MockEC2API) DescribeAccountAttributesWithContext(arg0 context.Context, arg1 *ec2.DescribeAccountAttributesInput, arg2 ...request.Option) (*ec2.DescribeAccountAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAccountAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddressTransfers mocks base method.
func (m *MockEC2API) DescribeAddressTransfers(arg0 *ec2.DescribeAddressTransfersInput) (*ec2.DescribeAddressTransfersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddressTransfers", arg0)
	ret0, _ := ret[0].(*ec2.DescribeAddressTransfersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeAddressTransfers indicates an expected call of DescribeAddressTransfers.
func (mr *MockEC2APIMockRecorder) DescribeAddressTransfers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfers", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressTransfers), arg0)
}

// DescribeAddressTransfersPages mocks base method.
func (m *MockEC2API) DescribeAddressTransfersPages(arg0 *ec2.DescribeAddressTransfersInput, arg1 func(*ec2.DescribeAddressTransfersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddressTransfersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeAddressTransfersPages indicates an expected call of DescribeAddressTransfersPages.
func (mr *MockEC2APIMockRecorder) DescribeAddressTransfersPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressTransfersPages), arg0, arg1)
}

// DescribeAddressTransfersPagesWithContext mocks base method.
func (m *MockEC2API) DescribeAddressTransfersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressTransfersInput, arg2 func(*ec2.DescribeAddressTransfersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddressTransfersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeAddressTransfersRequest mocks base method.
func (m *MockEC2API) DescribeAddressTransfersRequest(arg0 *ec2.DescribeAddressTransfersInput) (*request.Request, *ec2.DescribeAddressTransfersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddressTransfersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeAddressTransfersOutput)
	return ret0, ret1
}

// DescribeAddressTransfersRequest indicates an expected call of DescribeAddressTransfersRequest.
func (mr *MockEC2APIMockRecorder) DescribeAddressTransfersRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressTransfersRequest), arg0)
}

// DescribeAddressTransfersWithContext mocks base method.
func (m *MockEC2API) DescribeAddressTransfersWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressTransfersInput, arg2 ...request.Option) (*ec2.DescribeAddressTransfersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddressTransfersWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeAddressTransfersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddresses mocks base method.
func (m *MockEC2API) DescribeAddresses(arg0 *ec2.DescribeAddressesInput) (*ec2.DescribeAddressesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddresses", arg0)
	ret0, _ := ret[0].(*ec2.DescribeAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeAddresses indicates an expected call of DescribeAddresses.
func (mr *MockEC2APIMockRecorder) DescribeAddresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeAddresses), arg0)
}

// DescribeAddressesAttribute mocks base method.
func (m *MockEC2API) DescribeAddressesAttribute(arg0 *ec2.DescribeAddressesAttributeInput) (*ec2.DescribeAddressesAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddressesAttribute", arg0)
	ret0, _ := ret[0].(*ec2.DescribeAddressesAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeAddressesAttribute indicates an expected call of DescribeAddressesAttribute.
func (mr *MockEC2APIMockRecorder) DescribeAddressesAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttribute), arg0)
}

// DescribeAddressesAttributePages mocks base method.
func (m *MockEC2API) DescribeAddressesAttributePages(arg0 *ec2.DescribeAddressesAttributeInput, arg1 func(*ec2.DescribeAddressesAttributeOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddressesAttributePages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeAddressesAttributePages indicates an expected call of DescribeAddressesAttributePages.
func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributePages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributePages", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributePages), arg0, arg1)
}

// DescribeAddressesAttributePagesWithContext mocks base method.
func (m *MockEC2API) DescribeAddressesAttributePagesWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressesAttributeInput, arg2 func(*ec2.DescribeAddressesAttributeOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddressesAttributePagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeAddressesAttributeRequest mocks base method.
func (m *MockEC2API) DescribeAddressesAttributeRequest(arg0 *ec2.DescribeAddressesAttributeInput) (*request.Request, *ec2.DescribeAddressesAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddressesAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeAddressesAttributeOutput)
	return ret0, ret1
}

// DescribeAddressesAttributeRequest indicates an expected call of DescribeAddressesAttributeRequest.
func (mr *MockEC2APIMockRecorder) DescribeAddressesAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesAttributeRequest), arg0)
}

// DescribeAddressesAttributeWithContext mocks base method.
func (m *MockEC2API) DescribeAddressesAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressesAttributeInput, arg2 ...request.Option) (*ec2.DescribeAddressesAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddressesAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeAddressesAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddressesRequest mocks base method.
func (m *MockEC2API) DescribeAddressesRequest(arg0 *ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddressesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeAddressesOutput)
	return ret0, ret1
}

// DescribeAddressesRequest indicates an expected call of DescribeAddressesRequest.
func (mr *MockEC2APIMockRecorder) DescribeAddressesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesRequest), arg0)
}

// DescribeAddressesWithContext mocks base method.
func (m *MockEC2API) DescribeAddressesWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressesInput, arg2 ...request.Option) (*ec2.DescribeAddressesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddressesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAggregateIdFormat mocks base method.
func (m *MockEC2API) DescribeAggregateIdFormat(arg0 *ec2.DescribeAggregateIdFormatInput) (*ec2.DescribeAggregateIdFormatOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAggregateIdFormat", arg0)
	ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeAggregateIdFormat indicates an expected call of DescribeAggregateIdFormat.
func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormat(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormat), arg0)
}

// DescribeAggregateIdFormatRequest mocks base method.
func (m *MockEC2API) DescribeAggregateIdFormatRequest(arg0 *ec2.DescribeAggregateIdFormatInput) (*request.Request, *ec2.DescribeAggregateIdFormatOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAggregateIdFormatRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeAggregateIdFormatOutput)
	return ret0, ret1
}

// DescribeAggregateIdFormatRequest indicates an expected call of DescribeAggregateIdFormatRequest.
func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormatRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormatRequest), arg0)
}

// DescribeAggregateIdFormatWithContext mocks base method.
func (m *MockEC2API) DescribeAggregateIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeAggregateIdFormatInput, arg2 ...request.Option) (*ec2.DescribeAggregateIdFormatOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAggregateIdFormatWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAvailabilityZones mocks base method.
func (m *MockEC2API) DescribeAvailabilityZones(arg0 *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAvailabilityZones", arg0)
	ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeAvailabilityZones indicates an expected call of DescribeAvailabilityZones.
func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZones(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZones", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZones), arg0)
}

// DescribeAvailabilityZonesRequest mocks base method.
func (m *MockEC2API) DescribeAvailabilityZonesRequest(arg0 *ec2.DescribeAvailabilityZonesInput) (*request.Request, *ec2.DescribeAvailabilityZonesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAvailabilityZonesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeAvailabilityZonesOutput)
	return ret0, ret1
}

// DescribeAvailabilityZonesRequest indicates an expected call of DescribeAvailabilityZonesRequest.
func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZonesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZonesRequest), arg0)
}

// DescribeAvailabilityZonesWithContext mocks base method.
func (m *MockEC2API) DescribeAvailabilityZonesWithContext(arg0 context.Context, arg1 *ec2.DescribeAvailabilityZonesInput, arg2 ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAvailabilityZonesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAwsNetworkPerformanceMetricSubscriptions mocks base method.
func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptions(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptions", arg0)
	ret0, _ := ret[0].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeAwsNetworkPerformanceMetricSubscriptions indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptions.
func (mr *MockEC2APIMockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptions", reflect.TypeOf((*MockEC2API)(nil).DescribeAwsNetworkPerformanceMetricSubscriptions), arg0)
}

// DescribeAwsNetworkPerformanceMetricSubscriptionsPages mocks base method.
func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptionsPages(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg1 func(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeAwsNetworkPerformanceMetricSubscriptionsPages indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsPages.
func (mr *MockEC2APIMockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsPages), arg0, arg1)
}

// DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg2 func(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeAwsNetworkPerformanceMetricSubscriptionsRequest mocks base method.
func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptionsRequest(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput) (*request.Request, *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput)
	return ret0, ret1
}

// DescribeAwsNetworkPerformanceMetricSubscriptionsRequest indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsRequest), arg0)
}

// DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext mocks base method.
func (m *MockEC2API) DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext(arg0 context.Context, arg1 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg2 ...request.Option) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeBundleTasks mocks base method.
func (m *MockEC2API) DescribeBundleTasks(arg0 *ec2.DescribeBundleTasksInput) (*ec2.DescribeBundleTasksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBundleTasks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBundleTasks indicates an expected call of DescribeBundleTasks.
func (mr *MockEC2APIMockRecorder) DescribeBundleTasks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasks), arg0)
}

// DescribeBundleTasksRequest mocks base method.
func (m *MockEC2API) DescribeBundleTasksRequest(arg0 *ec2.DescribeBundleTasksInput) (*request.Request, *ec2.DescribeBundleTasksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBundleTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeBundleTasksOutput)
	return ret0, ret1
}

// DescribeBundleTasksRequest indicates an expected call of DescribeBundleTasksRequest.
func (mr *MockEC2APIMockRecorder) DescribeBundleTasksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasksRequest), arg0)
}

// DescribeBundleTasksWithContext mocks base method.
func (m *MockEC2API) DescribeBundleTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeBundleTasksInput, arg2 ...request.Option) (*ec2.DescribeBundleTasksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBundleTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeByoipCidrs mocks base method.
func (m *MockEC2API) DescribeByoipCidrs(arg0 *ec2.DescribeByoipCidrsInput) (*ec2.DescribeByoipCidrsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeByoipCidrs", arg0)
	ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeByoipCidrs indicates an expected call of DescribeByoipCidrs.
func (mr *MockEC2APIMockRecorder) DescribeByoipCidrs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrs", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrs), arg0)
}

// DescribeByoipCidrsPages mocks base method.
func (m *MockEC2API) DescribeByoipCidrsPages(arg0 *ec2.DescribeByoipCidrsInput, arg1 func(*ec2.DescribeByoipCidrsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeByoipCidrsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeByoipCidrsPages indicates an expected call of DescribeByoipCidrsPages.
func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsPages), arg0, arg1)
}

// DescribeByoipCidrsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeByoipCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 func(*ec2.DescribeByoipCidrsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeByoipCidrsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeByoipCidrsRequest mocks base method.
func (m *MockEC2API) DescribeByoipCidrsRequest(arg0 *ec2.DescribeByoipCidrsInput) (*request.Request, *ec2.DescribeByoipCidrsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeByoipCidrsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeByoipCidrsOutput)
	return ret0, ret1
}

// DescribeByoipCidrsRequest indicates an expected call of DescribeByoipCidrsRequest.
func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsRequest), arg0)
}

// DescribeByoipCidrsWithContext mocks base method.
func (m *MockEC2API) DescribeByoipCidrsWithContext(arg0 context.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 ...request.Option) (*ec2.DescribeByoipCidrsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeByoipCidrsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCapacityBlockOfferings mocks base method.
func (m *MockEC2API) DescribeCapacityBlockOfferings(arg0 *ec2.DescribeCapacityBlockOfferingsInput) (*ec2.DescribeCapacityBlockOfferingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferings", arg0)
	ret0, _ := ret[0].(*ec2.DescribeCapacityBlockOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCapacityBlockOfferings indicates an expected call of DescribeCapacityBlockOfferings.
func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferings), arg0)
}

// DescribeCapacityBlockOfferingsPages mocks base method.
func (m *MockEC2API) DescribeCapacityBlockOfferingsPages(arg0 *ec2.DescribeCapacityBlockOfferingsInput, arg1 func(*ec2.DescribeCapacityBlockOfferingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCapacityBlockOfferingsPages indicates an expected call of DescribeCapacityBlockOfferingsPages.
func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsPages), arg0, arg1)
}

// DescribeCapacityBlockOfferingsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeCapacityBlockOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityBlockOfferingsInput, arg2 func(*ec2.DescribeCapacityBlockOfferingsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeCapacityBlockOfferingsRequest mocks base method.
func (m *MockEC2API) DescribeCapacityBlockOfferingsRequest(arg0 *ec2.DescribeCapacityBlockOfferingsInput) (*request.Request, *ec2.DescribeCapacityBlockOfferingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeCapacityBlockOfferingsOutput)
	return ret0, ret1
}

// DescribeCapacityBlockOfferingsRequest indicates an expected call of DescribeCapacityBlockOfferingsRequest.
func (mr *MockEC2APIMockRecorder) DescribeCapacityBlockOfferingsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityBlockOfferingsRequest), arg0)
}

// DescribeCapacityBlockOfferingsWithContext mocks base method.
func (m *MockEC2API) DescribeCapacityBlockOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityBlockOfferingsInput, arg2 ...request.Option) (*ec2.DescribeCapacityBlockOfferingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeCapacityBlockOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCapacityReservationFleets mocks base method.
func (m *MockEC2API) DescribeCapacityReservationFleets(arg0 *ec2.DescribeCapacityReservationFleetsInput) (*ec2.DescribeCapacityReservationFleetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleets", arg0)
	ret0, _ := ret[0].(*ec2.DescribeCapacityReservationFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCapacityReservationFleets indicates an expected call of DescribeCapacityReservationFleets.
func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationFleets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleets", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationFleets), arg0)
}

// DescribeCapacityReservationFleetsPages mocks base method.
func (m *MockEC2API) DescribeCapacityReservationFleetsPages(arg0 *ec2.DescribeCapacityReservationFleetsInput, arg1 func(*ec2.DescribeCapacityReservationFleetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCapacityReservationFleetsPages indicates an expected call of DescribeCapacityReservationFleetsPages.
func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationFleetsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationFleetsPages), arg0, arg1)
}

// DescribeCapacityReservationFleetsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeCapacityReservationFleetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationFleetsInput, arg2 func(*ec2.DescribeCapacityReservationFleetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeCapacityReservationFleetsRequest mocks base method.
func (m *MockEC2API) DescribeCapacityReservationFleetsRequest(arg0 *ec2.DescribeCapacityReservationFleetsInput) (*request.Request, *ec2.DescribeCapacityReservationFleetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeCapacityReservationFleetsOutput)
	return ret0, ret1
}

// DescribeCapacityReservationFleetsRequest indicates an expected call of DescribeCapacityReservationFleetsRequest.
func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationFleetsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationFleetsRequest), arg0)
}

// DescribeCapacityReservationFleetsWithContext mocks base method.
func (m *MockEC2API) DescribeCapacityReservationFleetsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationFleetsInput, arg2 ...request.Option) (*ec2.DescribeCapacityReservationFleetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeCapacityReservationFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCapacityReservations mocks base method.
func (m *MockEC2API) DescribeCapacityReservations(arg0 *ec2.DescribeCapacityReservationsInput) (*ec2.DescribeCapacityReservationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityReservations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCapacityReservations indicates an expected call of DescribeCapacityReservations.
func (mr *MockEC2APIMockRecorder) DescribeCapacityReservations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservations), arg0)
}

// DescribeCapacityReservationsPages mocks base method.
func (m *MockEC2API) DescribeCapacityReservationsPages(arg0 *ec2.DescribeCapacityReservationsInput, arg1 func(*ec2.DescribeCapacityReservationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityReservationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCapacityReservationsPages indicates an expected call of DescribeCapacityReservationsPages.
func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsPages), arg0, arg1)
}

// DescribeCapacityReservationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeCapacityReservationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 func(*ec2.DescribeCapacityReservationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCapacityReservationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeCapacityReservationsRequest mocks base method.
func (m *MockEC2API) DescribeCapacityReservationsRequest(arg0 *ec2.DescribeCapacityReservationsInput) (*request.Request, *ec2.DescribeCapacityReservationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCapacityReservationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeCapacityReservationsOutput)
	return ret0, ret1
}

// DescribeCapacityReservationsRequest indicates an expected call of DescribeCapacityReservationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsRequest), arg0)
}

// DescribeCapacityReservationsWithContext mocks base method.
func (m *MockEC2API) DescribeCapacityReservationsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 ...request.Option) (*ec2.DescribeCapacityReservationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCapacityReservationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCarrierGateways mocks base method.
func (m *MockEC2API) DescribeCarrierGateways(arg0 *ec2.DescribeCarrierGatewaysInput) (*ec2.DescribeCarrierGatewaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCarrierGateways", arg0)
	ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCarrierGateways indicates an expected call of DescribeCarrierGateways.
func (mr *MockEC2APIMockRecorder) DescribeCarrierGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGateways), arg0)
}

// DescribeCarrierGatewaysPages mocks base method.
func (m *MockEC2API) DescribeCarrierGatewaysPages(arg0 *ec2.DescribeCarrierGatewaysInput, arg1 func(*ec2.DescribeCarrierGatewaysOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCarrierGatewaysPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCarrierGatewaysPages indicates an expected call of DescribeCarrierGatewaysPages.
func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysPages), arg0, arg1)
}

// DescribeCarrierGatewaysPagesWithContext mocks base method.
func (m *MockEC2API) DescribeCarrierGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 func(*ec2.DescribeCarrierGatewaysOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCarrierGatewaysPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeCarrierGatewaysRequest mocks base method.
func (m *MockEC2API) DescribeCarrierGatewaysRequest(arg0 *ec2.DescribeCarrierGatewaysInput) (*request.Request, *ec2.DescribeCarrierGatewaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCarrierGatewaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeCarrierGatewaysOutput)
	return ret0, ret1
}

// DescribeCarrierGatewaysRequest indicates an expected call of DescribeCarrierGatewaysRequest.
func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysRequest), arg0)
}

// DescribeCarrierGatewaysWithContext mocks base method.
func (m *MockEC2API) DescribeCarrierGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCarrierGatewaysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCarrierGatewaysWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClassicLinkInstances mocks base method.
func (m *MockEC2API) DescribeClassicLinkInstances(arg0 *ec2.DescribeClassicLinkInstancesInput) (*ec2.DescribeClassicLinkInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClassicLinkInstances", arg0)
	ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClassicLinkInstances indicates an expected call of DescribeClassicLinkInstances.
func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstances), arg0)
}

// DescribeClassicLinkInstancesPages mocks base method.
func (m *MockEC2API) DescribeClassicLinkInstancesPages(arg0 *ec2.DescribeClassicLinkInstancesInput, arg1 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeClassicLinkInstancesPages indicates an expected call of DescribeClassicLinkInstancesPages.
func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesPages), arg0, arg1)
}

// DescribeClassicLinkInstancesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeClassicLinkInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeClassicLinkInstancesRequest mocks base method.
func (m *MockEC2API) DescribeClassicLinkInstancesRequest(arg0 *ec2.DescribeClassicLinkInstancesInput) (*request.Request, *ec2.DescribeClassicLinkInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeClassicLinkInstancesOutput)
	return ret0, ret1
}

// DescribeClassicLinkInstancesRequest indicates an expected call of DescribeClassicLinkInstancesRequest.
func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesRequest), arg0)
}

// DescribeClassicLinkInstancesWithContext mocks base method.
func (m *MockEC2API) DescribeClassicLinkInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 ...request.Option) (*ec2.DescribeClassicLinkInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClientVpnAuthorizationRules mocks base method.
func (m *MockEC2API) DescribeClientVpnAuthorizationRules(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRules", arg0)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClientVpnAuthorizationRules indicates an expected call of DescribeClientVpnAuthorizationRules.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRules(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRules", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRules), arg0)
}

// DescribeClientVpnAuthorizationRulesPages mocks base method.
func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPages(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput, arg1 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeClientVpnAuthorizationRulesPages indicates an expected call of DescribeClientVpnAuthorizationRulesPages.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPages), arg0, arg1)
}

// DescribeClientVpnAuthorizationRulesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeClientVpnAuthorizationRulesRequest mocks base method.
func (m *MockEC2API) DescribeClientVpnAuthorizationRulesRequest(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*request.Request, *ec2.DescribeClientVpnAuthorizationRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
	return ret0, ret1
}

// DescribeClientVpnAuthorizationRulesRequest indicates an expected call of DescribeClientVpnAuthorizationRulesRequest.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesRequest), arg0)
}

// DescribeClientVpnAuthorizationRulesWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnAuthorizationRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClientVpnConnections mocks base method.
func (m *MockEC2API) DescribeClientVpnConnections(arg0 *ec2.DescribeClientVpnConnectionsInput) (*ec2.DescribeClientVpnConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnConnections", arg0)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClientVpnConnections indicates an expected call of DescribeClientVpnConnections.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnections(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnections), arg0)
}

// DescribeClientVpnConnectionsPages mocks base method.
func (m *MockEC2API) DescribeClientVpnConnectionsPages(arg0 *ec2.DescribeClientVpnConnectionsInput, arg1 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeClientVpnConnectionsPages indicates an expected call of DescribeClientVpnConnectionsPages.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPages), arg0, arg1)
}

// DescribeClientVpnConnectionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeClientVpnConnectionsRequest mocks base method.
func (m *MockEC2API) DescribeClientVpnConnectionsRequest(arg0 *ec2.DescribeClientVpnConnectionsInput) (*request.Request, *ec2.DescribeClientVpnConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeClientVpnConnectionsOutput)
	return ret0, ret1
}

// DescribeClientVpnConnectionsRequest indicates an expected call of DescribeClientVpnConnectionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsRequest), arg0)
}

// DescribeClientVpnConnectionsWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClientVpnEndpoints mocks base method.
func (m *MockEC2API) DescribeClientVpnEndpoints(arg0 *ec2.DescribeClientVpnEndpointsInput) (*ec2.DescribeClientVpnEndpointsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnEndpoints", arg0)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClientVpnEndpoints indicates an expected call of DescribeClientVpnEndpoints.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpoints), arg0)
}

// DescribeClientVpnEndpointsPages mocks base method.
func (m *MockEC2API) DescribeClientVpnEndpointsPages(arg0 *ec2.DescribeClientVpnEndpointsInput, arg1 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeClientVpnEndpointsPages indicates an expected call of DescribeClientVpnEndpointsPages.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsPages), arg0, arg1)
}

// DescribeClientVpnEndpointsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeClientVpnEndpointsRequest mocks base method.
func (m *MockEC2API) DescribeClientVpnEndpointsRequest(arg0 *ec2.DescribeClientVpnEndpointsInput) (*request.Request, *ec2.DescribeClientVpnEndpointsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeClientVpnEndpointsOutput)
	return ret0, ret1
}

// DescribeClientVpnEndpointsRequest indicates an expected call of DescribeClientVpnEndpointsRequest.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsRequest), arg0)
}

// DescribeClientVpnEndpointsWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnEndpointsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClientVpnRoutes mocks base method.
func (m *MockEC2API) DescribeClientVpnRoutes(arg0 *ec2.DescribeClientVpnRoutesInput) (*ec2.DescribeClientVpnRoutesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnRoutes", arg0)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClientVpnRoutes indicates an expected call of DescribeClientVpnRoutes.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutes", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutes), arg0)
}

// DescribeClientVpnRoutesPages mocks base method.
func (m *MockEC2API) DescribeClientVpnRoutesPages(arg0 *ec2.DescribeClientVpnRoutesInput, arg1 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnRoutesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeClientVpnRoutesPages indicates an expected call of DescribeClientVpnRoutesPages.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesPages), arg0, arg1)
}

// DescribeClientVpnRoutesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnRoutesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnRoutesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeClientVpnRoutesRequest mocks base method.
func (m *MockEC2API) DescribeClientVpnRoutesRequest(arg0 *ec2.DescribeClientVpnRoutesInput) (*request.Request, *ec2.DescribeClientVpnRoutesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnRoutesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeClientVpnRoutesOutput)
	return ret0, ret1
}

// DescribeClientVpnRoutesRequest indicates an expected call of DescribeClientVpnRoutesRequest.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesRequest), arg0)
}

// DescribeClientVpnRoutesWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnRoutesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnRoutesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnRoutesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClientVpnTargetNetworks mocks base method.
func (m *MockEC2API) DescribeClientVpnTargetNetworks(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*ec2.DescribeClientVpnTargetNetworksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClientVpnTargetNetworks indicates an expected call of DescribeClientVpnTargetNetworks.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworks", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworks), arg0)
}

// DescribeClientVpnTargetNetworksPages mocks base method.
func (m *MockEC2API) DescribeClientVpnTargetNetworksPages(arg0 *ec2.DescribeClientVpnTargetNetworksInput, arg1 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeClientVpnTargetNetworksPages indicates an expected call of DescribeClientVpnTargetNetworksPages.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPages), arg0, arg1)
}

// DescribeClientVpnTargetNetworksPagesWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnTargetNetworksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeClientVpnTargetNetworksRequest mocks base method.
func (m *MockEC2API) DescribeClientVpnTargetNetworksRequest(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*request.Request, *ec2.DescribeClientVpnTargetNetworksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeClientVpnTargetNetworksOutput)
	return ret0, ret1
}

// DescribeClientVpnTargetNetworksRequest indicates an expected call of DescribeClientVpnTargetNetworksRequest.
func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksRequest), arg0)
}

// DescribeClientVpnTargetNetworksWithContext mocks base method.
func (m *MockEC2API) DescribeClientVpnTargetNetworksWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 ...request.Option) (*ec2.DescribeClientVpnTargetNetworksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCoipPools mocks base method.
func (m *MockEC2API) DescribeCoipPools(arg0 *ec2.DescribeCoipPoolsInput) (*ec2.DescribeCoipPoolsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCoipPools", arg0)
	ret0, _ := ret[0].(*ec2.DescribeCoipPoolsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCoipPools indicates an expected call of DescribeCoipPools.
func (mr *MockEC2APIMockRecorder) DescribeCoipPools(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPools", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPools), arg0)
}

// DescribeCoipPoolsPages mocks base method.
func (m *MockEC2API) DescribeCoipPoolsPages(arg0 *ec2.DescribeCoipPoolsInput, arg1 func(*ec2.DescribeCoipPoolsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCoipPoolsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCoipPoolsPages indicates an expected call of DescribeCoipPoolsPages.
func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsPages), arg0, arg1)
}

// DescribeCoipPoolsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeCoipPoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCoipPoolsInput, arg2 func(*ec2.DescribeCoipPoolsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCoipPoolsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeCoipPoolsRequest mocks base method.
func (m *MockEC2API) DescribeCoipPoolsRequest(arg0 *ec2.DescribeCoipPoolsInput) (*request.Request, *ec2.DescribeCoipPoolsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCoipPoolsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeCoipPoolsOutput)
	return ret0, ret1
}

// DescribeCoipPoolsRequest indicates an expected call of DescribeCoipPoolsRequest.
func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsRequest), arg0)
}

// DescribeCoipPoolsWithContext mocks base method.
func (m *MockEC2API) DescribeCoipPoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeCoipPoolsInput, arg2 ...request.Option) (*ec2.DescribeCoipPoolsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCoipPoolsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeCoipPoolsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeConversionTasks mocks base method.
func (m *MockEC2API) DescribeConversionTasks(arg0 *ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeConversionTasks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeConversionTasks indicates an expected call of DescribeConversionTasks.
func (mr *MockEC2APIMockRecorder) DescribeConversionTasks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasks), arg0)
}

// DescribeConversionTasksRequest mocks base method.
func (m *MockEC2API) DescribeConversionTasksRequest(arg0 *ec2.DescribeConversionTasksInput) (*request.Request, *ec2.DescribeConversionTasksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeConversionTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeConversionTasksOutput)
	return ret0, ret1
}

// DescribeConversionTasksRequest indicates an expected call of DescribeConversionTasksRequest.
func (mr *MockEC2APIMockRecorder) DescribeConversionTasksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksRequest), arg0)
}

// DescribeConversionTasksWithContext mocks base method.
func (m *MockEC2API) DescribeConversionTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.Option) (*ec2.DescribeConversionTasksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeConversionTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCustomerGateways mocks base method.
func (m *MockEC2API) DescribeCustomerGateways(arg0 *ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCustomerGateways", arg0)
	ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCustomerGateways indicates an expected call of DescribeCustomerGateways.
func (mr *MockEC2APIMockRecorder) DescribeCustomerGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGateways), arg0)
}

// DescribeCustomerGatewaysRequest mocks base method.
func (m *MockEC2API) DescribeCustomerGatewaysRequest(arg0 *ec2.DescribeCustomerGatewaysInput) (*request.Request, *ec2.DescribeCustomerGatewaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCustomerGatewaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeCustomerGatewaysOutput)
	return ret0, ret1
}

// DescribeCustomerGatewaysRequest indicates an expected call of DescribeCustomerGatewaysRequest.
func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysRequest), arg0)
}

// DescribeCustomerGatewaysWithContext mocks base method.
func (m *MockEC2API) DescribeCustomerGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCustomerGatewaysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCustomerGatewaysWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDhcpOptions mocks base method.
func (m *MockEC2API) DescribeDhcpOptions(arg0 *ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDhcpOptions", arg0)
	ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeDhcpOptions indicates an expected call of DescribeDhcpOptions.
func (mr *MockEC2APIMockRecorder) DescribeDhcpOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptions), arg0)
}

// DescribeDhcpOptionsPages mocks base method.
func (m *MockEC2API) DescribeDhcpOptionsPages(arg0 *ec2.DescribeDhcpOptionsInput, arg1 func(*ec2.DescribeDhcpOptionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDhcpOptionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeDhcpOptionsPages indicates an expected call of DescribeDhcpOptionsPages.
func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsPages), arg0, arg1)
}

// DescribeDhcpOptionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeDhcpOptionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 func(*ec2.DescribeDhcpOptionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDhcpOptionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeDhcpOptionsRequest mocks base method.
func (m *MockEC2API) DescribeDhcpOptionsRequest(arg0 *ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDhcpOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeDhcpOptionsOutput)
	return ret0, ret1
}

// DescribeDhcpOptionsRequest indicates an expected call of DescribeDhcpOptionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsRequest), arg0)
}

// DescribeDhcpOptionsWithContext mocks base method.
func (m *MockEC2API) DescribeDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 ...request.Option) (*ec2.DescribeDhcpOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDhcpOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeEgressOnlyInternetGateways mocks base method.
func (m *MockEC2API) DescribeEgressOnlyInternetGateways(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGateways", arg0)
	ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeEgressOnlyInternetGateways indicates an expected call of DescribeEgressOnlyInternetGateways.
func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGateways), arg0)
}

// DescribeEgressOnlyInternetGatewaysPages mocks base method.
func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPages(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg1 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeEgressOnlyInternetGatewaysPages indicates an expected call of DescribeEgressOnlyInternetGatewaysPages.
func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPages), arg0, arg1)
}

// DescribeEgressOnlyInternetGatewaysPagesWithContext mocks base method.
func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeEgressOnlyInternetGatewaysRequest mocks base method.
func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysRequest(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*request.Request, *ec2.DescribeEgressOnlyInternetGatewaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
	return ret0, ret1
}

// DescribeEgressOnlyInternetGatewaysRequest indicates an expected call of DescribeEgressOnlyInternetGatewaysRequest.
func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysRequest), arg0)
}

// DescribeEgressOnlyInternetGatewaysWithContext mocks base method.
func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeElasticGpus mocks base method.
func (m *MockEC2API) DescribeElasticGpus(arg0 *ec2.DescribeElasticGpusInput) (*ec2.DescribeElasticGpusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeElasticGpus", arg0)
	ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeElasticGpus indicates an expected call of DescribeElasticGpus.
func (mr *MockEC2APIMockRecorder) DescribeElasticGpus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpus", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpus), arg0)
}

// DescribeElasticGpusRequest mocks base method.
func (m *MockEC2API) DescribeElasticGpusRequest(arg0 *ec2.DescribeElasticGpusInput) (*request.Request, *ec2.DescribeElasticGpusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeElasticGpusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeElasticGpusOutput)
	return ret0, ret1
}

// DescribeElasticGpusRequest indicates an expected call of DescribeElasticGpusRequest.
func (mr *MockEC2APIMockRecorder) DescribeElasticGpusRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpusRequest), arg0)
}

// DescribeElasticGpusWithContext mocks base method.
func (m *MockEC2API) DescribeElasticGpusWithContext(arg0 context.Context, arg1 *ec2.DescribeElasticGpusInput, arg2 ...request.Option) (*ec2.DescribeElasticGpusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeElasticGpusWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeExportImageTasks mocks base method.
func (m *MockEC2API) DescribeExportImageTasks(arg0 *ec2.DescribeExportImageTasksInput) (*ec2.DescribeExportImageTasksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExportImageTasks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeExportImageTasks indicates an expected call of DescribeExportImageTasks.
func (mr *MockEC2APIMockRecorder) DescribeExportImageTasks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasks), arg0)
}

// DescribeExportImageTasksPages mocks base method.
func (m *MockEC2API) DescribeExportImageTasksPages(arg0 *ec2.DescribeExportImageTasksInput, arg1 func(*ec2.DescribeExportImageTasksOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExportImageTasksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeExportImageTasksPages indicates an expected call of DescribeExportImageTasksPages.
func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksPages), arg0, arg1)
}

// DescribeExportImageTasksPagesWithContext mocks base method.
func (m *MockEC2API) DescribeExportImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 func(*ec2.DescribeExportImageTasksOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeExportImageTasksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeExportImageTasksRequest mocks base method.
func (m *MockEC2API) DescribeExportImageTasksRequest(arg0 *ec2.DescribeExportImageTasksInput) (*request.Request, *ec2.DescribeExportImageTasksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExportImageTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeExportImageTasksOutput)
	return ret0, ret1
}

// DescribeExportImageTasksRequest indicates an expected call of DescribeExportImageTasksRequest.
func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksRequest), arg0)
}

// DescribeExportImageTasksWithContext mocks base method.
func (m *MockEC2API) DescribeExportImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeExportImageTasksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeExportImageTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeExportTasks mocks base method.
func (m *MockEC2API) DescribeExportTasks(arg0 *ec2.DescribeExportTasksInput) (*ec2.DescribeExportTasksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExportTasks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeExportTasks indicates an expected call of DescribeExportTasks.
func (mr *MockEC2APIMockRecorder) DescribeExportTasks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasks), arg0)
}

// DescribeExportTasksRequest mocks base method.
func (m *MockEC2API) DescribeExportTasksRequest(arg0 *ec2.DescribeExportTasksInput) (*request.Request, *ec2.DescribeExportTasksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExportTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeExportTasksOutput)
	return ret0, ret1
}

// DescribeExportTasksRequest indicates an expected call of DescribeExportTasksRequest.
func (mr *MockEC2APIMockRecorder) DescribeExportTasksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasksRequest), arg0)
}

// DescribeExportTasksWithContext mocks base method.
func (m *MockEC2API) DescribeExportTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.Option) (*ec2.DescribeExportTasksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeExportTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFastLaunchImages mocks base method.
func (m *MockEC2API) DescribeFastLaunchImages(arg0 *ec2.DescribeFastLaunchImagesInput) (*ec2.DescribeFastLaunchImagesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFastLaunchImages", arg0)
	ret0, _ := ret[0].(*ec2.DescribeFastLaunchImagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeFastLaunchImages indicates an expected call of DescribeFastLaunchImages.
func (mr *MockEC2APIMockRecorder) DescribeFastLaunchImages(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImages", reflect.TypeOf((*MockEC2API)(nil).DescribeFastLaunchImages), arg0)
}

// DescribeFastLaunchImagesPages mocks base method.
func (m *MockEC2API) DescribeFastLaunchImagesPages(arg0 *ec2.DescribeFastLaunchImagesInput, arg1 func(*ec2.DescribeFastLaunchImagesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFastLaunchImagesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeFastLaunchImagesPages indicates an expected call of DescribeFastLaunchImagesPages.
func (mr *MockEC2APIMockRecorder) DescribeFastLaunchImagesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFastLaunchImagesPages), arg0, arg1)
}

// DescribeFastLaunchImagesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeFastLaunchImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastLaunchImagesInput, arg2 func(*ec2.DescribeFastLaunchImagesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFastLaunchImagesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFastLaunchImagesRequest mocks base method.
func (m *MockEC2API) DescribeFastLaunchImagesRequest(arg0 *ec2.DescribeFastLaunchImagesInput) (*request.Request, *ec2.DescribeFastLaunchImagesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFastLaunchImagesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeFastLaunchImagesOutput)
	return ret0, ret1
}

// DescribeFastLaunchImagesRequest indicates an expected call of DescribeFastLaunchImagesRequest.
func (mr *MockEC2APIMockRecorder) DescribeFastLaunchImagesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFastLaunchImagesRequest), arg0)
}

// DescribeFastLaunchImagesWithContext mocks base method.
func (m *MockEC2API) DescribeFastLaunchImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastLaunchImagesInput, arg2 ...request.Option) (*ec2.DescribeFastLaunchImagesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFastLaunchImagesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeFastLaunchImagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFastSnapshotRestores mocks base method.
func (m *MockEC2API) DescribeFastSnapshotRestores(arg0 *ec2.DescribeFastSnapshotRestoresInput) (*ec2.DescribeFastSnapshotRestoresOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestores", arg0)
	ret0, _ := ret[0].(*ec2.DescribeFastSnapshotRestoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeFastSnapshotRestores indicates an expected call of DescribeFastSnapshotRestores.
func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestores(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestores), arg0)
}

// DescribeFastSnapshotRestoresPages mocks base method.
func (m *MockEC2API) DescribeFastSnapshotRestoresPages(arg0 *ec2.DescribeFastSnapshotRestoresInput, arg1 func(*ec2.DescribeFastSnapshotRestoresOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeFastSnapshotRestoresPages indicates an expected call of DescribeFastSnapshotRestoresPages.
func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresPages), arg0, arg1)
}

// DescribeFastSnapshotRestoresPagesWithContext mocks base method.
func (m *MockEC2API) DescribeFastSnapshotRestoresPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastSnapshotRestoresInput, arg2 func(*ec2.DescribeFastSnapshotRestoresOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFastSnapshotRestoresRequest mocks base method.
func (m *MockEC2API) DescribeFastSnapshotRestoresRequest(arg0 *ec2.DescribeFastSnapshotRestoresInput) (*request.Request, *ec2.DescribeFastSnapshotRestoresOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeFastSnapshotRestoresOutput)
	return ret0, ret1
}

// DescribeFastSnapshotRestoresRequest indicates an expected call of DescribeFastSnapshotRestoresRequest.
func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresRequest), arg0)
}

// DescribeFastSnapshotRestoresWithContext mocks base method.
func (m *MockEC2API) DescribeFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.DescribeFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.DescribeFastSnapshotRestoresOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeFastSnapshotRestoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetHistory mocks base method.
func (m *MockEC2API) DescribeFleetHistory(arg0 *ec2.DescribeFleetHistoryInput) (*ec2.DescribeFleetHistoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetHistory", arg0)
	ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeFleetHistory indicates an expected call of DescribeFleetHistory.
func (mr *MockEC2APIMockRecorder) DescribeFleetHistory(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistory), arg0)
}

// DescribeFleetHistoryRequest mocks base method.
func (m *MockEC2API) DescribeFleetHistoryRequest(arg0 *ec2.DescribeFleetHistoryInput) (*request.Request, *ec2.DescribeFleetHistoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetHistoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeFleetHistoryOutput)
	return ret0, ret1
}

// DescribeFleetHistoryRequest indicates an expected call of DescribeFleetHistoryRequest.
func (mr *MockEC2APIMockRecorder) DescribeFleetHistoryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistoryRequest), arg0)
}

// DescribeFleetHistoryWithContext mocks base method.
func (m *MockEC2API) DescribeFleetHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetHistoryInput, arg2 ...request.Option) (*ec2.DescribeFleetHistoryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetHistoryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleetInstances mocks base method.
func (m *MockEC2API) DescribeFleetInstances(arg0 *ec2.DescribeFleetInstancesInput) (*ec2.DescribeFleetInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetInstances", arg0)
	ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeFleetInstances indicates an expected call of DescribeFleetInstances.
func (mr *MockEC2APIMockRecorder) DescribeFleetInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstances), arg0)
}

// DescribeFleetInstancesRequest mocks base method.
func (m *MockEC2API) DescribeFleetInstancesRequest(arg0 *ec2.DescribeFleetInstancesInput) (*request.Request, *ec2.DescribeFleetInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeFleetInstancesOutput)
	return ret0, ret1
}

// DescribeFleetInstancesRequest indicates an expected call of DescribeFleetInstancesRequest.
func (mr *MockEC2APIMockRecorder) DescribeFleetInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstancesRequest), arg0)
}

// DescribeFleetInstancesWithContext mocks base method.
func (m *MockEC2API) DescribeFleetInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeFleetInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFleets mocks base method.
func (m *MockEC2API) DescribeFleets(arg0 *ec2.DescribeFleetsInput) (*ec2.DescribeFleetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleets", arg0)
	ret0, _ := ret[0].(*ec2.DescribeFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeFleets indicates an expected call of DescribeFleets.
func (mr *MockEC2APIMockRecorder) DescribeFleets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleets", reflect.TypeOf((*MockEC2API)(nil).DescribeFleets), arg0)
}

// DescribeFleetsPages mocks base method.
func (m *MockEC2API) DescribeFleetsPages(arg0 *ec2.DescribeFleetsInput, arg1 func(*ec2.DescribeFleetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeFleetsPages indicates an expected call of DescribeFleetsPages.
func (mr *MockEC2APIMockRecorder) DescribeFleetsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsPages), arg0, arg1)
}

// DescribeFleetsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeFleetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetsInput, arg2 func(*ec2.DescribeFleetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFleetsRequest mocks base method.
func (m *MockEC2API) DescribeFleetsRequest(arg0 *ec2.DescribeFleetsInput) (*request.Request, *ec2.DescribeFleetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFleetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeFleetsOutput)
	return ret0, ret1
}

// DescribeFleetsRequest indicates an expected call of DescribeFleetsRequest.
func (mr *MockEC2APIMockRecorder) DescribeFleetsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsRequest), arg0)
}

// DescribeFleetsWithContext mocks base method.
func (m *MockEC2API) DescribeFleetsWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetsInput, arg2 ...request.Option) (*ec2.DescribeFleetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFleetsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeFleetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFlowLogs mocks base method.
func (m *MockEC2API) DescribeFlowLogs(arg0 *ec2.DescribeFlowLogsInput) (*ec2.DescribeFlowLogsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFlowLogs", arg0)
	ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeFlowLogs indicates an expected call of DescribeFlowLogs.
func (mr *MockEC2APIMockRecorder) DescribeFlowLogs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogs), arg0)
}

// DescribeFlowLogsPages mocks base method.
func (m *MockEC2API) DescribeFlowLogsPages(arg0 *ec2.DescribeFlowLogsInput, arg1 func(*ec2.DescribeFlowLogsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFlowLogsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeFlowLogsPages indicates an expected call of DescribeFlowLogsPages.
func (mr *MockEC2APIMockRecorder) DescribeFlowLogsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsPages), arg0, arg1)
}

// DescribeFlowLogsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeFlowLogsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 func(*ec2.DescribeFlowLogsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFlowLogsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFlowLogsRequest mocks base method.
func (m *MockEC2API) DescribeFlowLogsRequest(arg0 *ec2.DescribeFlowLogsInput) (*request.Request, *ec2.DescribeFlowLogsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFlowLogsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeFlowLogsOutput)
	return ret0, ret1
}

// DescribeFlowLogsRequest indicates an expected call of DescribeFlowLogsRequest.
func (mr *MockEC2APIMockRecorder) DescribeFlowLogsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsRequest), arg0)
}

// DescribeFlowLogsWithContext mocks base method.
func (m *MockEC2API) DescribeFlowLogsWithContext(arg0 context.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 ...request.Option) (*ec2.DescribeFlowLogsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFlowLogsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFpgaImageAttribute mocks base method.
func (m *MockEC2API) DescribeFpgaImageAttribute(arg0 *ec2.DescribeFpgaImageAttributeInput) (*ec2.DescribeFpgaImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFpgaImageAttribute", arg0)
	ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeFpgaImageAttribute indicates an expected call of DescribeFpgaImageAttribute.
func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttribute), arg0)
}

// DescribeFpgaImageAttributeRequest mocks base method.
func (m *MockEC2API) DescribeFpgaImageAttributeRequest(arg0 *ec2.DescribeFpgaImageAttributeInput) (*request.Request, *ec2.DescribeFpgaImageAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeFpgaImageAttributeOutput)
	return ret0, ret1
}

// DescribeFpgaImageAttributeRequest indicates an expected call of DescribeFpgaImageAttributeRequest.
func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttributeRequest), arg0)
}

// DescribeFpgaImageAttributeWithContext mocks base method.
func (m *MockEC2API) DescribeFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeFpgaImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFpgaImages mocks base method.
func (m *MockEC2API) DescribeFpgaImages(arg0 *ec2.DescribeFpgaImagesInput) (*ec2.DescribeFpgaImagesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFpgaImages", arg0)
	ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeFpgaImages indicates an expected call of DescribeFpgaImages.
func (mr *MockEC2APIMockRecorder) DescribeFpgaImages(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImages), arg0)
}

// DescribeFpgaImagesPages mocks base method.
func (m *MockEC2API) DescribeFpgaImagesPages(arg0 *ec2.DescribeFpgaImagesInput, arg1 func(*ec2.DescribeFpgaImagesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFpgaImagesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeFpgaImagesPages indicates an expected call of DescribeFpgaImagesPages.
func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesPages), arg0, arg1)
}

// DescribeFpgaImagesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeFpgaImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 func(*ec2.DescribeFpgaImagesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFpgaImagesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeFpgaImagesRequest mocks base method.
func (m *MockEC2API) DescribeFpgaImagesRequest(arg0 *ec2.DescribeFpgaImagesInput) (*request.Request, *ec2.DescribeFpgaImagesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFpgaImagesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeFpgaImagesOutput)
	return ret0, ret1
}

// DescribeFpgaImagesRequest indicates an expected call of DescribeFpgaImagesRequest.
func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesRequest), arg0)
}

// DescribeFpgaImagesWithContext mocks base method.
func (m *MockEC2API) DescribeFpgaImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 ...request.Option) (*ec2.DescribeFpgaImagesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFpgaImagesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHostReservationOfferings mocks base method.
func (m *MockEC2API) DescribeHostReservationOfferings(arg0 *ec2.DescribeHostReservationOfferingsInput) (*ec2.DescribeHostReservationOfferingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHostReservationOfferings", arg0)
	ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeHostReservationOfferings indicates an expected call of DescribeHostReservationOfferings.
func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferings), arg0)
}

// DescribeHostReservationOfferingsPages mocks base method.
func (m *MockEC2API) DescribeHostReservationOfferingsPages(arg0 *ec2.DescribeHostReservationOfferingsInput, arg1 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeHostReservationOfferingsPages indicates an expected call of DescribeHostReservationOfferingsPages.
func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsPages), arg0, arg1)
}

// DescribeHostReservationOfferingsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeHostReservationOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeHostReservationOfferingsRequest mocks base method.
func (m *MockEC2API) DescribeHostReservationOfferingsRequest(arg0 *ec2.DescribeHostReservationOfferingsInput) (*request.Request, *ec2.DescribeHostReservationOfferingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeHostReservationOfferingsOutput)
	return ret0, ret1
}

// DescribeHostReservationOfferingsRequest indicates an expected call of DescribeHostReservationOfferingsRequest.
func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsRequest), arg0)
}

// DescribeHostReservationOfferingsWithContext mocks base method.
func (m *MockEC2API) DescribeHostReservationOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationOfferingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHostReservations mocks base method.
func (m *MockEC2API) DescribeHostReservations(arg0 *ec2.DescribeHostReservationsInput) (*ec2.DescribeHostReservationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHostReservations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeHostReservations indicates an expected call of DescribeHostReservations.
func (mr *MockEC2APIMockRecorder) DescribeHostReservations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservations), arg0)
}

// DescribeHostReservationsPages mocks base method.
func (m *MockEC2API) DescribeHostReservationsPages(arg0 *ec2.DescribeHostReservationsInput, arg1 func(*ec2.DescribeHostReservationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHostReservationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeHostReservationsPages indicates an expected call of DescribeHostReservationsPages.
func (mr *MockEC2APIMockRecorder) DescribeHostReservationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsPages), arg0, arg1)
}

// DescribeHostReservationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeHostReservationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 func(*ec2.DescribeHostReservationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeHostReservationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeHostReservationsRequest mocks base method.
func (m *MockEC2API) DescribeHostReservationsRequest(arg0 *ec2.DescribeHostReservationsInput) (*request.Request, *ec2.DescribeHostReservationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHostReservationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeHostReservationsOutput)
	return ret0, ret1
}

// DescribeHostReservationsRequest indicates an expected call of DescribeHostReservationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeHostReservationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsRequest), arg0)
}

// DescribeHostReservationsWithContext mocks base method.
func (m *MockEC2API) DescribeHostReservationsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeHostReservationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHosts mocks base method.
func (m *MockEC2API) DescribeHosts(arg0 *ec2.DescribeHostsInput) (*ec2.DescribeHostsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHosts", arg0)
	ret0, _ := ret[0].(*ec2.DescribeHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeHosts indicates an expected call of DescribeHosts.
func (mr *MockEC2APIMockRecorder) DescribeHosts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHosts", reflect.TypeOf((*MockEC2API)(nil).DescribeHosts), arg0)
}

// DescribeHostsPages mocks base method.
func (m *MockEC2API) DescribeHostsPages(arg0 *ec2.DescribeHostsInput, arg1 func(*ec2.DescribeHostsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHostsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeHostsPages indicates an expected call of DescribeHostsPages.
func (mr *MockEC2APIMockRecorder) DescribeHostsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsPages), arg0, arg1)
}

// DescribeHostsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeHostsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostsInput, arg2 func(*ec2.DescribeHostsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeHostsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeHostsRequest mocks base method.
func (m *MockEC2API) DescribeHostsRequest(arg0 *ec2.DescribeHostsInput) (*request.Request, *ec2.DescribeHostsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHostsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeHostsOutput)
	return ret0, ret1
}

// DescribeHostsRequest indicates an expected call of DescribeHostsRequest.
func (mr *MockEC2APIMockRecorder) DescribeHostsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsRequest), arg0)
}

// DescribeHostsWithContext mocks base method.
func (m *MockEC2API) DescribeHostsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostsInput, arg2 ...request.Option) (*ec2.DescribeHostsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeHostsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIamInstanceProfileAssociations mocks base method.
func (m *MockEC2API) DescribeIamInstanceProfileAssociations(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIamInstanceProfileAssociations indicates an expected call of DescribeIamInstanceProfileAssociations.
func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociations), arg0)
}

// DescribeIamInstanceProfileAssociationsPages mocks base method.
func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPages(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput, arg1 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeIamInstanceProfileAssociationsPages indicates an expected call of DescribeIamInstanceProfileAssociationsPages.
func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPages), arg0, arg1)
}

// DescribeIamInstanceProfileAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeIamInstanceProfileAssociationsRequest mocks base method.
func (m *MockEC2API) DescribeIamInstanceProfileAssociationsRequest(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*request.Request, *ec2.DescribeIamInstanceProfileAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIamInstanceProfileAssociationsOutput)
	return ret0, ret1
}

// DescribeIamInstanceProfileAssociationsRequest indicates an expected call of DescribeIamInstanceProfileAssociationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsRequest), arg0)
}

// DescribeIamInstanceProfileAssociationsWithContext mocks base method.
func (m *MockEC2API) DescribeIamInstanceProfileAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 ...request.Option) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIdFormat mocks base method.
func (m *MockEC2API) DescribeIdFormat(arg0 *ec2.DescribeIdFormatInput) (*ec2.DescribeIdFormatOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIdFormat", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIdFormat indicates an expected call of DescribeIdFormat.
func (mr *MockEC2APIMockRecorder) DescribeIdFormat(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormat), arg0)
}

// DescribeIdFormatRequest mocks base method.
func (m *MockEC2API) DescribeIdFormatRequest(arg0 *ec2.DescribeIdFormatInput) (*request.Request, *ec2.DescribeIdFormatOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIdFormatRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIdFormatOutput)
	return ret0, ret1
}

// DescribeIdFormatRequest indicates an expected call of DescribeIdFormatRequest.
func (mr *MockEC2APIMockRecorder) DescribeIdFormatRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormatRequest), arg0)
}

// DescribeIdFormatWithContext mocks base method.
func (m *MockEC2API) DescribeIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdFormatOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIdFormatWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIdentityIdFormat mocks base method.
func (m *MockEC2API) DescribeIdentityIdFormat(arg0 *ec2.DescribeIdentityIdFormatInput) (*ec2.DescribeIdentityIdFormatOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIdentityIdFormat", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIdentityIdFormat indicates an expected call of DescribeIdentityIdFormat.
func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormat(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormat), arg0)
}

// DescribeIdentityIdFormatRequest mocks base method.
func (m *MockEC2API) DescribeIdentityIdFormatRequest(arg0 *ec2.DescribeIdentityIdFormatInput) (*request.Request, *ec2.DescribeIdentityIdFormatOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIdentityIdFormatRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIdentityIdFormatOutput)
	return ret0, ret1
}

// DescribeIdentityIdFormatRequest indicates an expected call of DescribeIdentityIdFormatRequest.
func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormatRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormatRequest), arg0)
}

// DescribeIdentityIdFormatWithContext mocks base method.
func (m *MockEC2API) DescribeIdentityIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeIdentityIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdentityIdFormatOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIdentityIdFormatWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeImageAttribute mocks base method.
func (m *MockEC2API) DescribeImageAttribute(arg0 *ec2.DescribeImageAttributeInput) (*ec2.DescribeImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImageAttribute", arg0)
	ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeImageAttribute indicates an expected call of DescribeImageAttribute.
func (mr *MockEC2APIMockRecorder) DescribeImageAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttribute), arg0)
}

// DescribeImageAttributeRequest mocks base method.
func (m *MockEC2API) DescribeImageAttributeRequest(arg0 *ec2.DescribeImageAttributeInput) (*request.Request, *ec2.DescribeImageAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImageAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeImageAttributeOutput)
	return ret0, ret1
}

// DescribeImageAttributeRequest indicates an expected call of DescribeImageAttributeRequest.
func (mr *MockEC2APIMockRecorder) DescribeImageAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttributeRequest), arg0)
}

// DescribeImageAttributeWithContext mocks base method.
func (m *MockEC2API) DescribeImageAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeImageAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeImages mocks base method.
func (m *MockEC2API) DescribeImages(arg0 *ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImages", arg0)
	ret0, _ := ret[0].(*ec2.DescribeImagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeImages indicates an expected call of DescribeImages.
func (mr *MockEC2APIMockRecorder) DescribeImages(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockEC2API)(nil).DescribeImages), arg0)
}

// DescribeImagesPages mocks base method.
func (m *MockEC2API) DescribeImagesPages(arg0 *ec2.DescribeImagesInput, arg1 func(*ec2.DescribeImagesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImagesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeImagesPages indicates an expected call of DescribeImagesPages.
func (mr *MockEC2APIMockRecorder) DescribeImagesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesPages), arg0, arg1)
}

// DescribeImagesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 func(*ec2.DescribeImagesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeImagesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeImagesRequest mocks base method.
func (m *MockEC2API) DescribeImagesRequest(arg0 *ec2.DescribeImagesInput) (*request.Request, *ec2.DescribeImagesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImagesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeImagesOutput)
	return ret0, ret1
}

// DescribeImagesRequest indicates an expected call of DescribeImagesRequest.
func (mr *MockEC2APIMockRecorder) DescribeImagesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesRequest), arg0)
}

// DescribeImagesWithContext mocks base method.
func (m *MockEC2API) DescribeImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.Option) (*ec2.DescribeImagesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeImagesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeImagesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeImportImageTasks mocks base method.
func (m *MockEC2API) DescribeImportImageTasks(arg0 *ec2.DescribeImportImageTasksInput) (*ec2.DescribeImportImageTasksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImportImageTasks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeImportImageTasks indicates an expected call of DescribeImportImageTasks.
func (mr *MockEC2APIMockRecorder) DescribeImportImageTasks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasks), arg0)
}

// DescribeImportImageTasksPages mocks base method.
func (m *MockEC2API) DescribeImportImageTasksPages(arg0 *ec2.DescribeImportImageTasksInput, arg1 func(*ec2.DescribeImportImageTasksOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImportImageTasksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeImportImageTasksPages indicates an expected call of DescribeImportImageTasksPages.
func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPages), arg0, arg1)
}

// DescribeImportImageTasksPagesWithContext mocks base method.
func (m *MockEC2API) DescribeImportImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 func(*ec2.DescribeImportImageTasksOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeImportImageTasksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeImportImageTasksRequest mocks base method.
func (m *MockEC2API) DescribeImportImageTasksRequest(arg0 *ec2.DescribeImportImageTasksInput) (*request.Request, *ec2.DescribeImportImageTasksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImportImageTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeImportImageTasksOutput)
	return ret0, ret1
}

// DescribeImportImageTasksRequest indicates an expected call of DescribeImportImageTasksRequest.
func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksRequest), arg0)
}

// DescribeImportImageTasksWithContext mocks base method.
func (m *MockEC2API) DescribeImportImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeImportImageTasksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeImportImageTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeImportSnapshotTasks mocks base method.
func (m *MockEC2API) DescribeImportSnapshotTasks(arg0 *ec2.DescribeImportSnapshotTasksInput) (*ec2.DescribeImportSnapshotTasksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeImportSnapshotTasks indicates an expected call of DescribeImportSnapshotTasks.
func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasks), arg0)
}

// DescribeImportSnapshotTasksPages mocks base method.
func (m *MockEC2API) DescribeImportSnapshotTasksPages(arg0 *ec2.DescribeImportSnapshotTasksInput, arg1 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeImportSnapshotTasksPages indicates an expected call of DescribeImportSnapshotTasksPages.
func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksPages), arg0, arg1)
}

// DescribeImportSnapshotTasksPagesWithContext mocks base method.
func (m *MockEC2API) DescribeImportSnapshotTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeImportSnapshotTasksRequest mocks base method.
func (m *MockEC2API) DescribeImportSnapshotTasksRequest(arg0 *ec2.DescribeImportSnapshotTasksInput) (*request.Request, *ec2.DescribeImportSnapshotTasksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeImportSnapshotTasksOutput)
	return ret0, ret1
}

// DescribeImportSnapshotTasksRequest indicates an expected call of DescribeImportSnapshotTasksRequest.
func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksRequest), arg0)
}

// DescribeImportSnapshotTasksWithContext mocks base method.
func (m *MockEC2API) DescribeImportSnapshotTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 ...request.Option) (*ec2.DescribeImportSnapshotTasksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceAttribute mocks base method.
func (m *MockEC2API) DescribeInstanceAttribute(arg0 *ec2.DescribeInstanceAttributeInput) (*ec2.DescribeInstanceAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceAttribute", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceAttribute indicates an expected call of DescribeInstanceAttribute.
func (mr *MockEC2APIMockRecorder) DescribeInstanceAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttribute), arg0)
}

// DescribeInstanceAttributeRequest mocks base method.
func (m *MockEC2API) DescribeInstanceAttributeRequest(arg0 *ec2.DescribeInstanceAttributeInput) (*request.Request, *ec2.DescribeInstanceAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceAttributeOutput)
	return ret0, ret1
}

// DescribeInstanceAttributeRequest indicates an expected call of DescribeInstanceAttributeRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttributeRequest), arg0)
}

// DescribeInstanceAttributeWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceAttributeInput, arg2 ...request.Option) (*ec2.DescribeInstanceAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceConnectEndpoints mocks base method.
func (m *MockEC2API) DescribeInstanceConnectEndpoints(arg0 *ec2.DescribeInstanceConnectEndpointsInput) (*ec2.DescribeInstanceConnectEndpointsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpoints", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceConnectEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceConnectEndpoints indicates an expected call of DescribeInstanceConnectEndpoints.
func (mr *MockEC2APIMockRecorder) DescribeInstanceConnectEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceConnectEndpoints), arg0)
}

// DescribeInstanceConnectEndpointsPages mocks base method.
func (m *MockEC2API) DescribeInstanceConnectEndpointsPages(arg0 *ec2.DescribeInstanceConnectEndpointsInput, arg1 func(*ec2.DescribeInstanceConnectEndpointsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInstanceConnectEndpointsPages indicates an expected call of DescribeInstanceConnectEndpointsPages.
func (mr *MockEC2APIMockRecorder) DescribeInstanceConnectEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceConnectEndpointsPages), arg0, arg1)
}

// DescribeInstanceConnectEndpointsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceConnectEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceConnectEndpointsInput, arg2 func(*ec2.DescribeInstanceConnectEndpointsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstanceConnectEndpointsRequest mocks base method.
func (m *MockEC2API) DescribeInstanceConnectEndpointsRequest(arg0 *ec2.DescribeInstanceConnectEndpointsInput) (*request.Request, *ec2.DescribeInstanceConnectEndpointsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceConnectEndpointsOutput)
	return ret0, ret1
}

// DescribeInstanceConnectEndpointsRequest indicates an expected call of DescribeInstanceConnectEndpointsRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceConnectEndpointsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceConnectEndpointsRequest), arg0)
}

// DescribeInstanceConnectEndpointsWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceConnectEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceConnectEndpointsInput, arg2 ...request.Option) (*ec2.DescribeInstanceConnectEndpointsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceConnectEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceCreditSpecifications mocks base method.
func (m *MockEC2API) DescribeInstanceCreditSpecifications(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecifications", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceCreditSpecifications indicates an expected call of DescribeInstanceCreditSpecifications.
func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecifications(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecifications", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecifications), arg0)
}

// DescribeInstanceCreditSpecificationsPages mocks base method.
func (m *MockEC2API) DescribeInstanceCreditSpecificationsPages(arg0 *ec2.DescribeInstanceCreditSpecificationsInput, arg1 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInstanceCreditSpecificationsPages indicates an expected call of DescribeInstanceCreditSpecificationsPages.
func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPages), arg0, arg1)
}

// DescribeInstanceCreditSpecificationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceCreditSpecificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstanceCreditSpecificationsRequest mocks base method.
func (m *MockEC2API) DescribeInstanceCreditSpecificationsRequest(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*request.Request, *ec2.DescribeInstanceCreditSpecificationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceCreditSpecificationsOutput)
	return ret0, ret1
}

// DescribeInstanceCreditSpecificationsRequest indicates an expected call of DescribeInstanceCreditSpecificationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsRequest), arg0)
}

// DescribeInstanceCreditSpecificationsWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceCreditSpecificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 ...request.Option) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceEventNotificationAttributes mocks base method.
func (m *MockEC2API) DescribeInstanceEventNotificationAttributes(arg0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributes", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceEventNotificationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceEventNotificationAttributes indicates an expected call of DescribeInstanceEventNotificationAttributes.
func (mr *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributes), arg0)
}

// DescribeInstanceEventNotificationAttributesRequest mocks base method.
func (m *MockEC2API) DescribeInstanceEventNotificationAttributesRequest(arg0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DescribeInstanceEventNotificationAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceEventNotificationAttributesOutput)
	return ret0, ret1
}

// DescribeInstanceEventNotificationAttributesRequest indicates an expected call of DescribeInstanceEventNotificationAttributesRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributesRequest), arg0)
}

// DescribeInstanceEventNotificationAttributesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceEventNotificationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceEventWindows mocks base method.
func (m *MockEC2API) DescribeInstanceEventWindows(arg0 *ec2.DescribeInstanceEventWindowsInput) (*ec2.DescribeInstanceEventWindowsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceEventWindows", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceEventWindowsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceEventWindows indicates an expected call of DescribeInstanceEventWindows.
func (mr *MockEC2APIMockRecorder) DescribeInstanceEventWindows(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindows", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventWindows), arg0)
}

// DescribeInstanceEventWindowsPages mocks base method.
func (m *MockEC2API) DescribeInstanceEventWindowsPages(arg0 *ec2.DescribeInstanceEventWindowsInput, arg1 func(*ec2.DescribeInstanceEventWindowsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInstanceEventWindowsPages indicates an expected call of DescribeInstanceEventWindowsPages.
func (mr *MockEC2APIMockRecorder) DescribeInstanceEventWindowsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindowsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventWindowsPages), arg0, arg1)
}

// DescribeInstanceEventWindowsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceEventWindowsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventWindowsInput, arg2 func(*ec2.DescribeInstanceEventWindowsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstanceEventWindowsRequest mocks base method.
func (m *MockEC2API) DescribeInstanceEventWindowsRequest(arg0 *ec2.DescribeInstanceEventWindowsInput) (*request.Request, *ec2.DescribeInstanceEventWindowsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceEventWindowsOutput)
	return ret0, ret1
}

// DescribeInstanceEventWindowsRequest indicates an expected call of DescribeInstanceEventWindowsRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceEventWindowsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindowsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventWindowsRequest), arg0)
}

// DescribeInstanceEventWindowsWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceEventWindowsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventWindowsInput, arg2 ...request.Option) (*ec2.DescribeInstanceEventWindowsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceEventWindowsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceStatus mocks base method.
func (m *MockEC2API) DescribeInstanceStatus(arg0 *ec2.DescribeInstanceStatusInput) (*ec2.DescribeInstanceStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceStatus", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceStatus indicates an expected call of DescribeInstanceStatus.
func (mr *MockEC2APIMockRecorder) DescribeInstanceStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatus), arg0)
}

// DescribeInstanceStatusPages mocks base method.
func (m *MockEC2API) DescribeInstanceStatusPages(arg0 *ec2.DescribeInstanceStatusInput, arg1 func(*ec2.DescribeInstanceStatusOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceStatusPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInstanceStatusPages indicates an expected call of DescribeInstanceStatusPages.
func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusPages), arg0, arg1)
}

// DescribeInstanceStatusPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 func(*ec2.DescribeInstanceStatusOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceStatusPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstanceStatusRequest mocks base method.
func (m *MockEC2API) DescribeInstanceStatusRequest(arg0 *ec2.DescribeInstanceStatusInput) (*request.Request, *ec2.DescribeInstanceStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceStatusOutput)
	return ret0, ret1
}

// DescribeInstanceStatusRequest indicates an expected call of DescribeInstanceStatusRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusRequest), arg0)
}

// DescribeInstanceStatusWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.Option) (*ec2.DescribeInstanceStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceStatusWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceTopology mocks base method.
func (m *MockEC2API) DescribeInstanceTopology(arg0 *ec2.DescribeInstanceTopologyInput) (*ec2.DescribeInstanceTopologyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTopology", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceTopologyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceTopology indicates an expected call of DescribeInstanceTopology.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTopology(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopology", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTopology), arg0)
}

// DescribeInstanceTopologyPages mocks base method.
func (m *MockEC2API) DescribeInstanceTopologyPages(arg0 *ec2.DescribeInstanceTopologyInput, arg1 func(*ec2.DescribeInstanceTopologyOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTopologyPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInstanceTopologyPages indicates an expected call of DescribeInstanceTopologyPages.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTopologyPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopologyPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTopologyPages), arg0, arg1)
}

// DescribeInstanceTopologyPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceTopologyPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTopologyInput, arg2 func(*ec2.DescribeInstanceTopologyOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceTopologyPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstanceTopologyRequest mocks base method.
func (m *MockEC2API) DescribeInstanceTopologyRequest(arg0 *ec2.DescribeInstanceTopologyInput) (*request.Request, *ec2.DescribeInstanceTopologyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTopologyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceTopologyOutput)
	return ret0, ret1
}

// DescribeInstanceTopologyRequest indicates an expected call of DescribeInstanceTopologyRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTopologyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopologyRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTopologyRequest), arg0)
}

// DescribeInstanceTopologyWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceTopologyWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTopologyInput, arg2 ...request.Option) (*ec2.DescribeInstanceTopologyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceTopologyWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceTopologyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceTypeOfferings mocks base method.
func (m *MockEC2API) DescribeInstanceTypeOfferings(arg0 *ec2.DescribeInstanceTypeOfferingsInput) (*ec2.DescribeInstanceTypeOfferingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferings", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceTypeOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceTypeOfferings indicates an expected call of DescribeInstanceTypeOfferings.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferings), arg0)
}

// DescribeInstanceTypeOfferingsPages mocks base method.
func (m *MockEC2API) DescribeInstanceTypeOfferingsPages(arg0 *ec2.DescribeInstanceTypeOfferingsInput, arg1 func(*ec2.DescribeInstanceTypeOfferingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInstanceTypeOfferingsPages indicates an expected call of DescribeInstanceTypeOfferingsPages.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsPages), arg0, arg1)
}

// DescribeInstanceTypeOfferingsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceTypeOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypeOfferingsInput, arg2 func(*ec2.DescribeInstanceTypeOfferingsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstanceTypeOfferingsRequest mocks base method.
func (m *MockEC2API) DescribeInstanceTypeOfferingsRequest(arg0 *ec2.DescribeInstanceTypeOfferingsInput) (*request.Request, *ec2.DescribeInstanceTypeOfferingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceTypeOfferingsOutput)
	return ret0, ret1
}

// DescribeInstanceTypeOfferingsRequest indicates an expected call of DescribeInstanceTypeOfferingsRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsRequest), arg0)
}

// DescribeInstanceTypeOfferingsWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceTypeOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypeOfferingsInput, arg2 ...request.Option) (*ec2.DescribeInstanceTypeOfferingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceTypeOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstanceTypes mocks base method.
func (m *MockEC2API) DescribeInstanceTypes(arg0 *ec2.DescribeInstanceTypesInput) (*ec2.DescribeInstanceTypesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTypes", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceTypes indicates an expected call of DescribeInstanceTypes.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTypes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypes), arg0)
}

// DescribeInstanceTypesPages mocks base method.
func (m *MockEC2API) DescribeInstanceTypesPages(arg0 *ec2.DescribeInstanceTypesInput, arg1 func(*ec2.DescribeInstanceTypesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTypesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInstanceTypesPages indicates an expected call of DescribeInstanceTypesPages.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesPages), arg0, arg1)
}

// DescribeInstanceTypesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceTypesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 func(*ec2.DescribeInstanceTypesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceTypesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstanceTypesRequest mocks base method.
func (m *MockEC2API) DescribeInstanceTypesRequest(arg0 *ec2.DescribeInstanceTypesInput) (*request.Request, *ec2.DescribeInstanceTypesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTypesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstanceTypesOutput)
	return ret0, ret1
}

// DescribeInstanceTypesRequest indicates an expected call of DescribeInstanceTypesRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesRequest), arg0)
}

// DescribeInstanceTypesWithContext mocks base method.
func (m *MockEC2API) DescribeInstanceTypesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 ...request.Option) (*ec2.DescribeInstanceTypesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstanceTypesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInstances mocks base method.
func (m *MockEC2API) DescribeInstances(arg0 *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstances", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstances indicates an expected call of DescribeInstances.
func (mr *MockEC2APIMockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeInstances), arg0)
}

// DescribeInstancesPages mocks base method.
func (m *MockEC2API) DescribeInstancesPages(arg0 *ec2.DescribeInstancesInput, arg1 func(*ec2.DescribeInstancesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstancesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInstancesPages indicates an expected call of DescribeInstancesPages.
func (mr *MockEC2APIMockRecorder) DescribeInstancesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesPages), arg0, arg1)
}

// DescribeInstancesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 func(*ec2.DescribeInstancesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstancesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInstancesRequest mocks base method.
func (m *MockEC2API) DescribeInstancesRequest(arg0 *ec2.DescribeInstancesInput) (*request.Request, *ec2.DescribeInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInstancesOutput)
	return ret0, ret1
}

// DescribeInstancesRequest indicates an expected call of DescribeInstancesRequest.
func (mr *MockEC2APIMockRecorder) DescribeInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesRequest), arg0)
}

// DescribeInstancesWithContext mocks base method.
func (m *MockEC2API) DescribeInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.Option) (*ec2.DescribeInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeInternetGateways mocks base method.
func (m *MockEC2API) DescribeInternetGateways(arg0 *ec2.DescribeInternetGatewaysInput) (*ec2.DescribeInternetGatewaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInternetGateways", arg0)
	ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInternetGateways indicates an expected call of DescribeInternetGateways.
func (mr *MockEC2APIMockRecorder) DescribeInternetGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGateways), arg0)
}

// DescribeInternetGatewaysPages mocks base method.
func (m *MockEC2API) DescribeInternetGatewaysPages(arg0 *ec2.DescribeInternetGatewaysInput, arg1 func(*ec2.DescribeInternetGatewaysOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInternetGatewaysPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeInternetGatewaysPages indicates an expected call of DescribeInternetGatewaysPages.
func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysPages), arg0, arg1)
}

// DescribeInternetGatewaysPagesWithContext mocks base method.
func (m *MockEC2API) DescribeInternetGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 func(*ec2.DescribeInternetGatewaysOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInternetGatewaysPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeInternetGatewaysRequest mocks base method.
func (m *MockEC2API) DescribeInternetGatewaysRequest(arg0 *ec2.DescribeInternetGatewaysInput) (*request.Request, *ec2.DescribeInternetGatewaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInternetGatewaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeInternetGatewaysOutput)
	return ret0, ret1
}

// DescribeInternetGatewaysRequest indicates an expected call of DescribeInternetGatewaysRequest.
func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysRequest), arg0)
}

// DescribeInternetGatewaysWithContext mocks base method.
func (m *MockEC2API) DescribeInternetGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeInternetGatewaysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInternetGatewaysWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpamByoasn mocks base method.
func (m *MockEC2API) DescribeIpamByoasn(arg0 *ec2.DescribeIpamByoasnInput) (*ec2.DescribeIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamByoasn", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIpamByoasn indicates an expected call of DescribeIpamByoasn.
func (mr *MockEC2APIMockRecorder) DescribeIpamByoasn(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamByoasn), arg0)
}

// DescribeIpamByoasnRequest mocks base method.
func (m *MockEC2API) DescribeIpamByoasnRequest(arg0 *ec2.DescribeIpamByoasnInput) (*request.Request, *ec2.DescribeIpamByoasnOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamByoasnRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIpamByoasnOutput)
	return ret0, ret1
}

// DescribeIpamByoasnRequest indicates an expected call of DescribeIpamByoasnRequest.
func (mr *MockEC2APIMockRecorder) DescribeIpamByoasnRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamByoasnRequest), arg0)
}

// DescribeIpamByoasnWithContext mocks base method.
func (m *MockEC2API) DescribeIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamByoasnInput, arg2 ...request.Option) (*ec2.DescribeIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamByoasnWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpamExternalResourceVerificationTokens mocks base method.
func (m *MockEC2API) DescribeIpamExternalResourceVerificationTokens(arg0 *ec2.DescribeIpamExternalResourceVerificationTokensInput) (*ec2.DescribeIpamExternalResourceVerificationTokensOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamExternalResourceVerificationTokens", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIpamExternalResourceVerificationTokensOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIpamExternalResourceVerificationTokens indicates an expected call of DescribeIpamExternalResourceVerificationTokens.
func (mr *MockEC2APIMockRecorder) DescribeIpamExternalResourceVerificationTokens(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamExternalResourceVerificationTokens", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamExternalResourceVerificationTokens), arg0)
}

// DescribeIpamExternalResourceVerificationTokensRequest mocks base method.
func (m *MockEC2API) DescribeIpamExternalResourceVerificationTokensRequest(arg0 *ec2.DescribeIpamExternalResourceVerificationTokensInput) (*request.Request, *ec2.DescribeIpamExternalResourceVerificationTokensOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamExternalResourceVerificationTokensRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIpamExternalResourceVerificationTokensOutput)
	return ret0, ret1
}

// DescribeIpamExternalResourceVerificationTokensRequest indicates an expected call of DescribeIpamExternalResourceVerificationTokensRequest.
func (mr *MockEC2APIMockRecorder) DescribeIpamExternalResourceVerificationTokensRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamExternalResourceVerificationTokensRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamExternalResourceVerificationTokensRequest), arg0)
}

// DescribeIpamExternalResourceVerificationTokensWithContext mocks base method.
func (m *MockEC2API) DescribeIpamExternalResourceVerificationTokensWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamExternalResourceVerificationTokensInput, arg2 ...request.Option) (*ec2.DescribeIpamExternalResourceVerificationTokensOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamExternalResourceVerificationTokensWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIpamExternalResourceVerificationTokensOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpamPools mocks base method.
func (m *MockEC2API) DescribeIpamPools(arg0 *ec2.DescribeIpamPoolsInput) (*ec2.DescribeIpamPoolsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamPools", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIpamPoolsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIpamPools indicates an expected call of DescribeIpamPools.
func (mr *MockEC2APIMockRecorder) DescribeIpamPools(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPools", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPools), arg0)
}

// DescribeIpamPoolsPages mocks base method.
func (m *MockEC2API) DescribeIpamPoolsPages(arg0 *ec2.DescribeIpamPoolsInput, arg1 func(*ec2.DescribeIpamPoolsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamPoolsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeIpamPoolsPages indicates an expected call of DescribeIpamPoolsPages.
func (mr *MockEC2APIMockRecorder) DescribeIpamPoolsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPoolsPages), arg0, arg1)
}

// DescribeIpamPoolsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeIpamPoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamPoolsInput, arg2 func(*ec2.DescribeIpamPoolsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamPoolsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeIpamPoolsRequest mocks base method.
func (m *MockEC2API) DescribeIpamPoolsRequest(arg0 *ec2.DescribeIpamPoolsInput) (*request.Request, *ec2.DescribeIpamPoolsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamPoolsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIpamPoolsOutput)
	return ret0, ret1
}

// DescribeIpamPoolsRequest indicates an expected call of DescribeIpamPoolsRequest.
func (mr *MockEC2APIMockRecorder) DescribeIpamPoolsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamPoolsRequest), arg0)
}

// DescribeIpamPoolsWithContext mocks base method.
func (m *MockEC2API) DescribeIpamPoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamPoolsInput, arg2 ...request.Option) (*ec2.DescribeIpamPoolsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamPoolsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIpamPoolsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpamResourceDiscoveries mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveries(arg0 *ec2.DescribeIpamResourceDiscoveriesInput) (*ec2.DescribeIpamResourceDiscoveriesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveries", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIpamResourceDiscoveries indicates an expected call of DescribeIpamResourceDiscoveries.
func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveries(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveries", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveries), arg0)
}

// DescribeIpamResourceDiscoveriesPages mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveriesPages(arg0 *ec2.DescribeIpamResourceDiscoveriesInput, arg1 func(*ec2.DescribeIpamResourceDiscoveriesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeIpamResourceDiscoveriesPages indicates an expected call of DescribeIpamResourceDiscoveriesPages.
func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveriesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveriesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveriesPages), arg0, arg1)
}

// DescribeIpamResourceDiscoveriesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveriesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveriesInput, arg2 func(*ec2.DescribeIpamResourceDiscoveriesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeIpamResourceDiscoveriesRequest mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveriesRequest(arg0 *ec2.DescribeIpamResourceDiscoveriesInput) (*request.Request, *ec2.DescribeIpamResourceDiscoveriesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIpamResourceDiscoveriesOutput)
	return ret0, ret1
}

// DescribeIpamResourceDiscoveriesRequest indicates an expected call of DescribeIpamResourceDiscoveriesRequest.
func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveriesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveriesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveriesRequest), arg0)
}

// DescribeIpamResourceDiscoveriesWithContext mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveriesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveriesInput, arg2 ...request.Option) (*ec2.DescribeIpamResourceDiscoveriesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpamResourceDiscoveryAssociations mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociations(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIpamResourceDiscoveryAssociations indicates an expected call of DescribeIpamResourceDiscoveryAssociations.
func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveryAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveryAssociations), arg0)
}

// DescribeIpamResourceDiscoveryAssociationsPages mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociationsPages(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg1 func(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeIpamResourceDiscoveryAssociationsPages indicates an expected call of DescribeIpamResourceDiscoveryAssociationsPages.
func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveryAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveryAssociationsPages), arg0, arg1)
}

// DescribeIpamResourceDiscoveryAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg2 func(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeIpamResourceDiscoveryAssociationsRequest mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociationsRequest(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput) (*request.Request, *ec2.DescribeIpamResourceDiscoveryAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput)
	return ret0, ret1
}

// DescribeIpamResourceDiscoveryAssociationsRequest indicates an expected call of DescribeIpamResourceDiscoveryAssociationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeIpamResourceDiscoveryAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamResourceDiscoveryAssociationsRequest), arg0)
}

// DescribeIpamResourceDiscoveryAssociationsWithContext mocks base method.
func (m *MockEC2API) DescribeIpamResourceDiscoveryAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg2 ...request.Option) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpamScopes mocks base method.
func (m *MockEC2API) DescribeIpamScopes(arg0 *ec2.DescribeIpamScopesInput) (*ec2.DescribeIpamScopesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamScopes", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIpamScopesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIpamScopes indicates an expected call of DescribeIpamScopes.
func (mr *MockEC2APIMockRecorder) DescribeIpamScopes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopes", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamScopes), arg0)
}

// DescribeIpamScopesPages mocks base method.
func (m *MockEC2API) DescribeIpamScopesPages(arg0 *ec2.DescribeIpamScopesInput, arg1 func(*ec2.DescribeIpamScopesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamScopesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeIpamScopesPages indicates an expected call of DescribeIpamScopesPages.
func (mr *MockEC2APIMockRecorder) DescribeIpamScopesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamScopesPages), arg0, arg1)
}

// DescribeIpamScopesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeIpamScopesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamScopesInput, arg2 func(*ec2.DescribeIpamScopesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamScopesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeIpamScopesRequest mocks base method.
func (m *MockEC2API) DescribeIpamScopesRequest(arg0 *ec2.DescribeIpamScopesInput) (*request.Request, *ec2.DescribeIpamScopesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamScopesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIpamScopesOutput)
	return ret0, ret1
}

// DescribeIpamScopesRequest indicates an expected call of DescribeIpamScopesRequest.
func (mr *MockEC2APIMockRecorder) DescribeIpamScopesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamScopesRequest), arg0)
}

// DescribeIpamScopesWithContext mocks base method.
func (m *MockEC2API) DescribeIpamScopesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamScopesInput, arg2 ...request.Option) (*ec2.DescribeIpamScopesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamScopesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIpamScopesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpams mocks base method.
func (m *MockEC2API) DescribeIpams(arg0 *ec2.DescribeIpamsInput) (*ec2.DescribeIpamsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpams", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIpamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIpams indicates an expected call of DescribeIpams.
func (mr *MockEC2APIMockRecorder) DescribeIpams(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpams", reflect.TypeOf((*MockEC2API)(nil).DescribeIpams), arg0)
}

// DescribeIpamsPages mocks base method.
func (m *MockEC2API) DescribeIpamsPages(arg0 *ec2.DescribeIpamsInput, arg1 func(*ec2.DescribeIpamsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeIpamsPages indicates an expected call of DescribeIpamsPages.
func (mr *MockEC2APIMockRecorder) DescribeIpamsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamsPages), arg0, arg1)
}

// DescribeIpamsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeIpamsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamsInput, arg2 func(*ec2.DescribeIpamsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeIpamsRequest mocks base method.
func (m *MockEC2API) DescribeIpamsRequest(arg0 *ec2.DescribeIpamsInput) (*request.Request, *ec2.DescribeIpamsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpamsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIpamsOutput)
	return ret0, ret1
}

// DescribeIpamsRequest indicates an expected call of DescribeIpamsRequest.
func (mr *MockEC2APIMockRecorder) DescribeIpamsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpamsRequest), arg0)
}

// DescribeIpamsWithContext mocks base method.
func (m *MockEC2API) DescribeIpamsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamsInput, arg2 ...request.Option) (*ec2.DescribeIpamsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpamsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIpamsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIpv6Pools mocks base method.
func (m *MockEC2API) DescribeIpv6Pools(arg0 *ec2.DescribeIpv6PoolsInput) (*ec2.DescribeIpv6PoolsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpv6Pools", arg0)
	ret0, _ := ret[0].(*ec2.DescribeIpv6PoolsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeIpv6Pools indicates an expected call of DescribeIpv6Pools.
func (mr *MockEC2APIMockRecorder) DescribeIpv6Pools(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6Pools", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6Pools), arg0)
}

// DescribeIpv6PoolsPages mocks base method.
func (m *MockEC2API) DescribeIpv6PoolsPages(arg0 *ec2.DescribeIpv6PoolsInput, arg1 func(*ec2.DescribeIpv6PoolsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpv6PoolsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeIpv6PoolsPages indicates an expected call of DescribeIpv6PoolsPages.
func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsPages), arg0, arg1)
}

// DescribeIpv6PoolsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeIpv6PoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpv6PoolsInput, arg2 func(*ec2.DescribeIpv6PoolsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpv6PoolsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeIpv6PoolsRequest mocks base method.
func (m *MockEC2API) DescribeIpv6PoolsRequest(arg0 *ec2.DescribeIpv6PoolsInput) (*request.Request, *ec2.DescribeIpv6PoolsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIpv6PoolsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeIpv6PoolsOutput)
	return ret0, ret1
}

// DescribeIpv6PoolsRequest indicates an expected call of DescribeIpv6PoolsRequest.
func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsRequest), arg0)
}

// DescribeIpv6PoolsWithContext mocks base method.
func (m *MockEC2API) DescribeIpv6PoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpv6PoolsInput, arg2 ...request.Option) (*ec2.DescribeIpv6PoolsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIpv6PoolsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeIpv6PoolsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeKeyPairs mocks base method.
func (m *MockEC2API) DescribeKeyPairs(arg0 *ec2.DescribeKeyPairsInput) (*ec2.DescribeKeyPairsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeKeyPairs", arg0)
	ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeKeyPairs indicates an expected call of DescribeKeyPairs.
func (mr *MockEC2APIMockRecorder) DescribeKeyPairs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairs", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairs), arg0)
}

// DescribeKeyPairsRequest mocks base method.
func (m *MockEC2API) DescribeKeyPairsRequest(arg0 *ec2.DescribeKeyPairsInput) (*request.Request, *ec2.DescribeKeyPairsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeKeyPairsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeKeyPairsOutput)
	return ret0, ret1
}

// DescribeKeyPairsRequest indicates an expected call of DescribeKeyPairsRequest.
func (mr *MockEC2APIMockRecorder) DescribeKeyPairsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairsRequest), arg0)
}

// DescribeKeyPairsWithContext mocks base method.
func (m *MockEC2API) DescribeKeyPairsWithContext(arg0 context.Context, arg1 *ec2.DescribeKeyPairsInput, arg2 ...request.Option) (*ec2.DescribeKeyPairsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeKeyPairsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLaunchTemplateVersions mocks base method.
func (m *MockEC2API) DescribeLaunchTemplateVersions(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*ec2.DescribeLaunchTemplateVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersions", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLaunchTemplateVersions indicates an expected call of DescribeLaunchTemplateVersions.
func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersions), arg0)
}

// DescribeLaunchTemplateVersionsPages mocks base method.
func (m *MockEC2API) DescribeLaunchTemplateVersionsPages(arg0 *ec2.DescribeLaunchTemplateVersionsInput, arg1 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeLaunchTemplateVersionsPages indicates an expected call of DescribeLaunchTemplateVersionsPages.
func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPages), arg0, arg1)
}

// DescribeLaunchTemplateVersionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeLaunchTemplateVersionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeLaunchTemplateVersionsRequest mocks base method.
func (m *MockEC2API) DescribeLaunchTemplateVersionsRequest(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*request.Request, *ec2.DescribeLaunchTemplateVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLaunchTemplateVersionsOutput)
	return ret0, ret1
}

// DescribeLaunchTemplateVersionsRequest indicates an expected call of DescribeLaunchTemplateVersionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsRequest), arg0)
}

// DescribeLaunchTemplateVersionsWithContext mocks base method.
func (m *MockEC2API) DescribeLaunchTemplateVersionsWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplateVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLaunchTemplates mocks base method.
func (m *MockEC2API) DescribeLaunchTemplates(arg0 *ec2.DescribeLaunchTemplatesInput) (*ec2.DescribeLaunchTemplatesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLaunchTemplates", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLaunchTemplates indicates an expected call of DescribeLaunchTemplates.
func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplates(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplates", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplates), arg0)
}

// DescribeLaunchTemplatesPages mocks base method.
func (m *MockEC2API) DescribeLaunchTemplatesPages(arg0 *ec2.DescribeLaunchTemplatesInput, arg1 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLaunchTemplatesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeLaunchTemplatesPages indicates an expected call of DescribeLaunchTemplatesPages.
func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesPages), arg0, arg1)
}

// DescribeLaunchTemplatesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeLaunchTemplatesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLaunchTemplatesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeLaunchTemplatesRequest mocks base method.
func (m *MockEC2API) DescribeLaunchTemplatesRequest(arg0 *ec2.DescribeLaunchTemplatesInput) (*request.Request, *ec2.DescribeLaunchTemplatesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLaunchTemplatesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLaunchTemplatesOutput)
	return ret0, ret1
}

// DescribeLaunchTemplatesRequest indicates an expected call of DescribeLaunchTemplatesRequest.
func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesRequest), arg0)
}

// DescribeLaunchTemplatesWithContext mocks base method.
func (m *MockEC2API) DescribeLaunchTemplatesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplatesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLaunchTemplatesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations), arg0)
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg1 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages), arg0, arg1)
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg2 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
	return ret0, ret1
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest), arg0)
}

// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLocalGatewayRouteTableVpcAssociations mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociations(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLocalGatewayRouteTableVpcAssociations indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociations.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociations), arg0)
}

// DescribeLocalGatewayRouteTableVpcAssociationsPages mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg1 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeLocalGatewayRouteTableVpcAssociationsPages indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsPages.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPages), arg0, arg1)
}

// DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg2 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeLocalGatewayRouteTableVpcAssociationsRequest mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
	return ret0, ret1
}

// DescribeLocalGatewayRouteTableVpcAssociationsRequest indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsRequest), arg0)
}

// DescribeLocalGatewayRouteTableVpcAssociationsWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLocalGatewayRouteTables mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTables(arg0 *ec2.DescribeLocalGatewayRouteTablesInput) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTables", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLocalGatewayRouteTables indicates an expected call of DescribeLocalGatewayRouteTables.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTables(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTables), arg0)
}

// DescribeLocalGatewayRouteTablesPages mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTablesPages(arg0 *ec2.DescribeLocalGatewayRouteTablesInput, arg1 func(*ec2.DescribeLocalGatewayRouteTablesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeLocalGatewayRouteTablesPages indicates an expected call of DescribeLocalGatewayRouteTablesPages.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesPages), arg0, arg1)
}

// DescribeLocalGatewayRouteTablesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTablesInput, arg2 func(*ec2.DescribeLocalGatewayRouteTablesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeLocalGatewayRouteTablesRequest mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTablesRequest(arg0 *ec2.DescribeLocalGatewayRouteTablesInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTablesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTablesOutput)
	return ret0, ret1
}

// DescribeLocalGatewayRouteTablesRequest indicates an expected call of DescribeLocalGatewayRouteTablesRequest.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesRequest), arg0)
}

// DescribeLocalGatewayRouteTablesWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLocalGatewayVirtualInterfaceGroups mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroups(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroups", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLocalGatewayVirtualInterfaceGroups indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroups.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroups), arg0)
}

// DescribeLocalGatewayVirtualInterfaceGroupsPages mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg1 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeLocalGatewayVirtualInterfaceGroupsPages indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsPages.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPages), arg0, arg1)
}

// DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg2 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeLocalGatewayVirtualInterfaceGroupsRequest mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
	return ret0, ret1
}

// DescribeLocalGatewayVirtualInterfaceGroupsRequest indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsRequest.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsRequest), arg0)
}

// DescribeLocalGatewayVirtualInterfaceGroupsWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLocalGatewayVirtualInterfaces mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaces(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaces", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLocalGatewayVirtualInterfaces indicates an expected call of DescribeLocalGatewayVirtualInterfaces.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaces(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaces), arg0)
}

// DescribeLocalGatewayVirtualInterfacesPages mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesPages(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg1 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeLocalGatewayVirtualInterfacesPages indicates an expected call of DescribeLocalGatewayVirtualInterfacesPages.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesPages), arg0, arg1)
}

// DescribeLocalGatewayVirtualInterfacesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg2 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeLocalGatewayVirtualInterfacesRequest mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesRequest(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfacesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
	return ret0, ret1
}

// DescribeLocalGatewayVirtualInterfacesRequest indicates an expected call of DescribeLocalGatewayVirtualInterfacesRequest.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesRequest), arg0)
}

// DescribeLocalGatewayVirtualInterfacesWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLocalGateways mocks base method.
func (m *MockEC2API) DescribeLocalGateways(arg0 *ec2.DescribeLocalGatewaysInput) (*ec2.DescribeLocalGatewaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGateways", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLocalGateways indicates an expected call of DescribeLocalGateways.
func (mr *MockEC2APIMockRecorder) DescribeLocalGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGateways), arg0)
}

// DescribeLocalGatewaysPages mocks base method.
func (m *MockEC2API) DescribeLocalGatewaysPages(arg0 *ec2.DescribeLocalGatewaysInput, arg1 func(*ec2.DescribeLocalGatewaysOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewaysPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeLocalGatewaysPages indicates an expected call of DescribeLocalGatewaysPages.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysPages), arg0, arg1)
}

// DescribeLocalGatewaysPagesWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewaysInput, arg2 func(*ec2.DescribeLocalGatewaysOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewaysPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeLocalGatewaysRequest mocks base method.
func (m *MockEC2API) DescribeLocalGatewaysRequest(arg0 *ec2.DescribeLocalGatewaysInput) (*request.Request, *ec2.DescribeLocalGatewaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLocalGatewaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLocalGatewaysOutput)
	return ret0, ret1
}

// DescribeLocalGatewaysRequest indicates an expected call of DescribeLocalGatewaysRequest.
func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysRequest), arg0)
}

// DescribeLocalGatewaysWithContext mocks base method.
func (m *MockEC2API) DescribeLocalGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewaysInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewaysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLocalGatewaysWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLocalGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeLockedSnapshots mocks base method.
func (m *MockEC2API) DescribeLockedSnapshots(arg0 *ec2.DescribeLockedSnapshotsInput) (*ec2.DescribeLockedSnapshotsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLockedSnapshots", arg0)
	ret0, _ := ret[0].(*ec2.DescribeLockedSnapshotsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLockedSnapshots indicates an expected call of DescribeLockedSnapshots.
func (mr *MockEC2APIMockRecorder) DescribeLockedSnapshots(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLockedSnapshots", reflect.TypeOf((*MockEC2API)(nil).DescribeLockedSnapshots), arg0)
}

// DescribeLockedSnapshotsRequest mocks base method.
func (m *MockEC2API) DescribeLockedSnapshotsRequest(arg0 *ec2.DescribeLockedSnapshotsInput) (*request.Request, *ec2.DescribeLockedSnapshotsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLockedSnapshotsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeLockedSnapshotsOutput)
	return ret0, ret1
}

// DescribeLockedSnapshotsRequest indicates an expected call of DescribeLockedSnapshotsRequest.
func (mr *MockEC2APIMockRecorder) DescribeLockedSnapshotsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLockedSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLockedSnapshotsRequest), arg0)
}

// DescribeLockedSnapshotsWithContext mocks base method.
func (m *MockEC2API) DescribeLockedSnapshotsWithContext(arg0 context.Context, arg1 *ec2.DescribeLockedSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeLockedSnapshotsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLockedSnapshotsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeLockedSnapshotsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMacHosts mocks base method.
func (m *MockEC2API) DescribeMacHosts(arg0 *ec2.DescribeMacHostsInput) (*ec2.DescribeMacHostsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMacHosts", arg0)
	ret0, _ := ret[0].(*ec2.DescribeMacHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeMacHosts indicates an expected call of DescribeMacHosts.
func (mr *MockEC2APIMockRecorder) DescribeMacHosts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMacHosts", reflect.TypeOf((*MockEC2API)(nil).DescribeMacHosts), arg0)
}

// DescribeMacHostsPages mocks base method.
func (m *MockEC2API) DescribeMacHostsPages(arg0 *ec2.DescribeMacHostsInput, arg1 func(*ec2.DescribeMacHostsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMacHostsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeMacHostsPages indicates an expected call of DescribeMacHostsPages.
func (mr *MockEC2APIMockRecorder) DescribeMacHostsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMacHostsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeMacHostsPages), arg0, arg1)
}

// DescribeMacHostsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeMacHostsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeMacHostsInput, arg2 func(*ec2.DescribeMacHostsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMacHostsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeMacHostsRequest mocks base method.
func (m *MockEC2API) DescribeMacHostsRequest(arg0 *ec2.DescribeMacHostsInput) (*request.Request, *ec2.DescribeMacHostsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMacHostsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeMacHostsOutput)
	return ret0, ret1
}

// DescribeMacHostsRequest indicates an expected call of DescribeMacHostsRequest.
func (mr *MockEC2APIMockRecorder) DescribeMacHostsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMacHostsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeMacHostsRequest), arg0)
}

// DescribeMacHostsWithContext mocks base method.
func (m *MockEC2API) DescribeMacHostsWithContext(arg0 context.Context, arg1 *ec2.DescribeMacHostsInput, arg2 ...request.Option) (*ec2.DescribeMacHostsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMacHostsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeMacHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeManagedPrefixLists mocks base method.
func (m *MockEC2API) DescribeManagedPrefixLists(arg0 *ec2.DescribeManagedPrefixListsInput) (*ec2.DescribeManagedPrefixListsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeManagedPrefixLists", arg0)
	ret0, _ := ret[0].(*ec2.DescribeManagedPrefixListsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeManagedPrefixLists indicates an expected call of DescribeManagedPrefixLists.
func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixLists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixLists", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixLists), arg0)
}

// DescribeManagedPrefixListsPages mocks base method.
func (m *MockEC2API) DescribeManagedPrefixListsPages(arg0 *ec2.DescribeManagedPrefixListsInput, arg1 func(*ec2.DescribeManagedPrefixListsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeManagedPrefixListsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeManagedPrefixListsPages indicates an expected call of DescribeManagedPrefixListsPages.
func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsPages), arg0, arg1)
}

// DescribeManagedPrefixListsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeManagedPrefixListsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeManagedPrefixListsInput, arg2 func(*ec2.DescribeManagedPrefixListsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeManagedPrefixListsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeManagedPrefixListsRequest mocks base method.
func (m *MockEC2API) DescribeManagedPrefixListsRequest(arg0 *ec2.DescribeManagedPrefixListsInput) (*request.Request, *ec2.DescribeManagedPrefixListsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeManagedPrefixListsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeManagedPrefixListsOutput)
	return ret0, ret1
}

// DescribeManagedPrefixListsRequest indicates an expected call of DescribeManagedPrefixListsRequest.
func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsRequest), arg0)
}

// DescribeManagedPrefixListsWithContext mocks base method.
func (m *MockEC2API) DescribeManagedPrefixListsWithContext(arg0 context.Context, arg1 *ec2.DescribeManagedPrefixListsInput, arg2 ...request.Option) (*ec2.DescribeManagedPrefixListsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeManagedPrefixListsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeManagedPrefixListsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMovingAddresses mocks base method.
func (m *MockEC2API) DescribeMovingAddresses(arg0 *ec2.DescribeMovingAddressesInput) (*ec2.DescribeMovingAddressesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMovingAddresses", arg0)
	ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeMovingAddresses indicates an expected call of DescribeMovingAddresses.
func (mr *MockEC2APIMockRecorder) DescribeMovingAddresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddresses), arg0)
}

// DescribeMovingAddressesPages mocks base method.
func (m *MockEC2API) DescribeMovingAddressesPages(arg0 *ec2.DescribeMovingAddressesInput, arg1 func(*ec2.DescribeMovingAddressesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMovingAddressesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeMovingAddressesPages indicates an expected call of DescribeMovingAddressesPages.
func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesPages), arg0, arg1)
}

// DescribeMovingAddressesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeMovingAddressesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 func(*ec2.DescribeMovingAddressesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMovingAddressesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeMovingAddressesRequest mocks base method.
func (m *MockEC2API) DescribeMovingAddressesRequest(arg0 *ec2.DescribeMovingAddressesInput) (*request.Request, *ec2.DescribeMovingAddressesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMovingAddressesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeMovingAddressesOutput)
	return ret0, ret1
}

// DescribeMovingAddressesRequest indicates an expected call of DescribeMovingAddressesRequest.
func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesRequest), arg0)
}

// DescribeMovingAddressesWithContext mocks base method.
func (m *MockEC2API) DescribeMovingAddressesWithContext(arg0 context.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 ...request.Option) (*ec2.DescribeMovingAddressesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMovingAddressesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNatGateways mocks base method.
func (m *MockEC2API) DescribeNatGateways(arg0 *ec2.DescribeNatGatewaysInput) (*ec2.DescribeNatGatewaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNatGateways", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNatGateways indicates an expected call of DescribeNatGateways.
func (mr *MockEC2APIMockRecorder) DescribeNatGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGateways), arg0)
}

// DescribeNatGatewaysPages mocks base method.
func (m *MockEC2API) DescribeNatGatewaysPages(arg0 *ec2.DescribeNatGatewaysInput, arg1 func(*ec2.DescribeNatGatewaysOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNatGatewaysPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNatGatewaysPages indicates an expected call of DescribeNatGatewaysPages.
func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysPages), arg0, arg1)
}

// DescribeNatGatewaysPagesWithContext mocks base method.
func (m *MockEC2API) DescribeNatGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 func(*ec2.DescribeNatGatewaysOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNatGatewaysPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNatGatewaysRequest mocks base method.
func (m *MockEC2API) DescribeNatGatewaysRequest(arg0 *ec2.DescribeNatGatewaysInput) (*request.Request, *ec2.DescribeNatGatewaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNatGatewaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNatGatewaysOutput)
	return ret0, ret1
}

// DescribeNatGatewaysRequest indicates an expected call of DescribeNatGatewaysRequest.
func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysRequest), arg0)
}

// DescribeNatGatewaysWithContext mocks base method.
func (m *MockEC2API) DescribeNatGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.Option) (*ec2.DescribeNatGatewaysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNatGatewaysWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNetworkAcls mocks base method.
func (m *MockEC2API) DescribeNetworkAcls(arg0 *ec2.DescribeNetworkAclsInput) (*ec2.DescribeNetworkAclsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkAcls", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNetworkAcls indicates an expected call of DescribeNetworkAcls.
func (mr *MockEC2APIMockRecorder) DescribeNetworkAcls(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAcls", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAcls), arg0)
}

// DescribeNetworkAclsPages mocks base method.
func (m *MockEC2API) DescribeNetworkAclsPages(arg0 *ec2.DescribeNetworkAclsInput, arg1 func(*ec2.DescribeNetworkAclsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkAclsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNetworkAclsPages indicates an expected call of DescribeNetworkAclsPages.
func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsPages), arg0, arg1)
}

// DescribeNetworkAclsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkAclsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 func(*ec2.DescribeNetworkAclsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkAclsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNetworkAclsRequest mocks base method.
func (m *MockEC2API) DescribeNetworkAclsRequest(arg0 *ec2.DescribeNetworkAclsInput) (*request.Request, *ec2.DescribeNetworkAclsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkAclsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNetworkAclsOutput)
	return ret0, ret1
}

// DescribeNetworkAclsRequest indicates an expected call of DescribeNetworkAclsRequest.
func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsRequest), arg0)
}

// DescribeNetworkAclsWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkAclsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 ...request.Option) (*ec2.DescribeNetworkAclsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkAclsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNetworkInsightsAccessScopeAnalyses mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalyses(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalyses", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNetworkInsightsAccessScopeAnalyses indicates an expected call of DescribeNetworkInsightsAccessScopeAnalyses.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopeAnalyses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalyses", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopeAnalyses), arg0)
}

// DescribeNetworkInsightsAccessScopeAnalysesPages mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalysesPages(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg1 func(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNetworkInsightsAccessScopeAnalysesPages indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesPages.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopeAnalysesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalysesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopeAnalysesPages), arg0, arg1)
}

// DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg2 func(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNetworkInsightsAccessScopeAnalysesRequest mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalysesRequest(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput) (*request.Request, *ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput)
	return ret0, ret1
}

// DescribeNetworkInsightsAccessScopeAnalysesRequest indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesRequest.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopeAnalysesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalysesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopeAnalysesRequest), arg0)
}

// DescribeNetworkInsightsAccessScopeAnalysesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopeAnalysesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNetworkInsightsAccessScopes mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopes(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopes", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNetworkInsightsAccessScopes indicates an expected call of DescribeNetworkInsightsAccessScopes.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopes", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopes), arg0)
}

// DescribeNetworkInsightsAccessScopesPages mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopesPages(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput, arg1 func(*ec2.DescribeNetworkInsightsAccessScopesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNetworkInsightsAccessScopesPages indicates an expected call of DescribeNetworkInsightsAccessScopesPages.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopesPages), arg0, arg1)
}

// DescribeNetworkInsightsAccessScopesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopesInput, arg2 func(*ec2.DescribeNetworkInsightsAccessScopesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNetworkInsightsAccessScopesRequest mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopesRequest(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput) (*request.Request, *ec2.DescribeNetworkInsightsAccessScopesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAccessScopesOutput)
	return ret0, ret1
}

// DescribeNetworkInsightsAccessScopesRequest indicates an expected call of DescribeNetworkInsightsAccessScopesRequest.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAccessScopesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAccessScopesRequest), arg0)
}

// DescribeNetworkInsightsAccessScopesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAccessScopesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNetworkInsightsAnalyses mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAnalyses(arg0 *ec2.DescribeNetworkInsightsAnalysesInput) (*ec2.DescribeNetworkInsightsAnalysesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalyses", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNetworkInsightsAnalyses indicates an expected call of DescribeNetworkInsightsAnalyses.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalyses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalyses", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalyses), arg0)
}

// DescribeNetworkInsightsAnalysesPages mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAnalysesPages(arg0 *ec2.DescribeNetworkInsightsAnalysesInput, arg1 func(*ec2.DescribeNetworkInsightsAnalysesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNetworkInsightsAnalysesPages indicates an expected call of DescribeNetworkInsightsAnalysesPages.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalysesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesPages), arg0, arg1)
}

// DescribeNetworkInsightsAnalysesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAnalysesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAnalysesInput, arg2 func(*ec2.DescribeNetworkInsightsAnalysesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNetworkInsightsAnalysesRequest mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAnalysesRequest(arg0 *ec2.DescribeNetworkInsightsAnalysesInput) (*request.Request, *ec2.DescribeNetworkInsightsAnalysesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAnalysesOutput)
	return ret0, ret1
}

// DescribeNetworkInsightsAnalysesRequest indicates an expected call of DescribeNetworkInsightsAnalysesRequest.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsAnalysesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalysesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsAnalysesRequest), arg0)
}

// DescribeNetworkInsightsAnalysesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsAnalysesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAnalysesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAnalysesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsAnalysesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAnalysesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNetworkInsightsPaths mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsPaths(arg0 *ec2.DescribeNetworkInsightsPathsInput) (*ec2.DescribeNetworkInsightsPathsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPaths", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsPathsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNetworkInsightsPaths indicates an expected call of DescribeNetworkInsightsPaths.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPaths(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPaths", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPaths), arg0)
}

// DescribeNetworkInsightsPathsPages mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsPathsPages(arg0 *ec2.DescribeNetworkInsightsPathsInput, arg1 func(*ec2.DescribeNetworkInsightsPathsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNetworkInsightsPathsPages indicates an expected call of DescribeNetworkInsightsPathsPages.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPathsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsPages), arg0, arg1)
}

// DescribeNetworkInsightsPathsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsPathsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsPathsInput, arg2 func(*ec2.DescribeNetworkInsightsPathsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNetworkInsightsPathsRequest mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsPathsRequest(arg0 *ec2.DescribeNetworkInsightsPathsInput) (*request.Request, *ec2.DescribeNetworkInsightsPathsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsPathsOutput)
	return ret0, ret1
}

// DescribeNetworkInsightsPathsRequest indicates an expected call of DescribeNetworkInsightsPathsRequest.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInsightsPathsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPathsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInsightsPathsRequest), arg0)
}

// DescribeNetworkInsightsPathsWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInsightsPathsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsPathsInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsPathsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInsightsPathsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsPathsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNetworkInterfaceAttribute mocks base method.
func (m *MockEC2API) DescribeNetworkInterfaceAttribute(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttribute", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNetworkInterfaceAttribute indicates an expected call of DescribeNetworkInterfaceAttribute.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttribute), arg0)
}

// DescribeNetworkInterfaceAttributeRequest mocks base method.
func (m *MockEC2API) DescribeNetworkInterfaceAttributeRequest(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*request.Request, *ec2.DescribeNetworkInterfaceAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNetworkInterfaceAttributeOutput)
	return ret0, ret1
}

// DescribeNetworkInterfaceAttributeRequest indicates an expected call of DescribeNetworkInterfaceAttributeRequest.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeRequest), arg0)
}

// DescribeNetworkInterfaceAttributeWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNetworkInterfacePermissions mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacePermissions(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissions", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNetworkInterfacePermissions indicates an expected call of DescribeNetworkInterfacePermissions.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissions), arg0)
}

// DescribeNetworkInterfacePermissionsPages mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacePermissionsPages(arg0 *ec2.DescribeNetworkInterfacePermissionsInput, arg1 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNetworkInterfacePermissionsPages indicates an expected call of DescribeNetworkInterfacePermissionsPages.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPages), arg0, arg1)
}

// DescribeNetworkInterfacePermissionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacePermissionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNetworkInterfacePermissionsRequest mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacePermissionsRequest(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*request.Request, *ec2.DescribeNetworkInterfacePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacePermissionsOutput)
	return ret0, ret1
}

// DescribeNetworkInterfacePermissionsRequest indicates an expected call of DescribeNetworkInterfacePermissionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsRequest), arg0)
}

// DescribeNetworkInterfacePermissionsWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacePermissionsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNetworkInterfaces mocks base method.
func (m *MockEC2API) DescribeNetworkInterfaces(arg0 *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInterfaces", arg0)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNetworkInterfaces indicates an expected call of DescribeNetworkInterfaces.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaces(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaces), arg0)
}

// DescribeNetworkInterfacesPages mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacesPages(arg0 *ec2.DescribeNetworkInterfacesInput, arg1 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeNetworkInterfacesPages indicates an expected call of DescribeNetworkInterfacesPages.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesPages), arg0, arg1)
}

// DescribeNetworkInterfacesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeNetworkInterfacesRequest mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacesRequest(arg0 *ec2.DescribeNetworkInterfacesInput) (*request.Request, *ec2.DescribeNetworkInterfacesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacesOutput)
	return ret0, ret1
}

// DescribeNetworkInterfacesRequest indicates an expected call of DescribeNetworkInterfacesRequest.
func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesRequest), arg0)
}

// DescribeNetworkInterfacesWithContext mocks base method.
func (m *MockEC2API) DescribeNetworkInterfacesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNetworkInterfacesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePlacementGroups mocks base method.
func (m *MockEC2API) DescribePlacementGroups(arg0 *ec2.DescribePlacementGroupsInput) (*ec2.DescribePlacementGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePlacementGroups", arg0)
	ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribePlacementGroups indicates an expected call of DescribePlacementGroups.
func (mr *MockEC2APIMockRecorder) DescribePlacementGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroups", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroups), arg0)
}

// DescribePlacementGroupsRequest mocks base method.
func (m *MockEC2API) DescribePlacementGroupsRequest(arg0 *ec2.DescribePlacementGroupsInput) (*request.Request, *ec2.DescribePlacementGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePlacementGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribePlacementGroupsOutput)
	return ret0, ret1
}

// DescribePlacementGroupsRequest indicates an expected call of DescribePlacementGroupsRequest.
func (mr *MockEC2APIMockRecorder) DescribePlacementGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroupsRequest), arg0)
}

// DescribePlacementGroupsWithContext mocks base method.
func (m *MockEC2API) DescribePlacementGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribePlacementGroupsInput, arg2 ...request.Option) (*ec2.DescribePlacementGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePlacementGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePrefixLists mocks base method.
func (m *MockEC2API) DescribePrefixLists(arg0 *ec2.DescribePrefixListsInput) (*ec2.DescribePrefixListsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePrefixLists", arg0)
	ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribePrefixLists indicates an expected call of DescribePrefixLists.
func (mr *MockEC2APIMockRecorder) DescribePrefixLists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixLists", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixLists), arg0)
}

// DescribePrefixListsPages mocks base method.
func (m *MockEC2API) DescribePrefixListsPages(arg0 *ec2.DescribePrefixListsInput, arg1 func(*ec2.DescribePrefixListsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePrefixListsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribePrefixListsPages indicates an expected call of DescribePrefixListsPages.
func (mr *MockEC2APIMockRecorder) DescribePrefixListsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsPages), arg0, arg1)
}

// DescribePrefixListsPagesWithContext mocks base method.
func (m *MockEC2API) DescribePrefixListsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePrefixListsInput, arg2 func(*ec2.DescribePrefixListsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePrefixListsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribePrefixListsRequest mocks base method.
func (m *MockEC2API) DescribePrefixListsRequest(arg0 *ec2.DescribePrefixListsInput) (*request.Request, *ec2.DescribePrefixListsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePrefixListsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribePrefixListsOutput)
	return ret0, ret1
}

// DescribePrefixListsRequest indicates an expected call of DescribePrefixListsRequest.
func (mr *MockEC2APIMockRecorder) DescribePrefixListsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsRequest), arg0)
}

// DescribePrefixListsWithContext mocks base method.
func (m *MockEC2API) DescribePrefixListsWithContext(arg0 context.Context, arg1 *ec2.DescribePrefixListsInput, arg2 ...request.Option) (*ec2.DescribePrefixListsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePrefixListsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePrincipalIdFormat mocks base method.
func (m *MockEC2API) DescribePrincipalIdFormat(arg0 *ec2.DescribePrincipalIdFormatInput) (*ec2.DescribePrincipalIdFormatOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePrincipalIdFormat", arg0)
	ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribePrincipalIdFormat indicates an expected call of DescribePrincipalIdFormat.
func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormat(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormat), arg0)
}

// DescribePrincipalIdFormatPages mocks base method.
func (m *MockEC2API) DescribePrincipalIdFormatPages(arg0 *ec2.DescribePrincipalIdFormatInput, arg1 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePrincipalIdFormatPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribePrincipalIdFormatPages indicates an expected call of DescribePrincipalIdFormatPages.
func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatPages), arg0, arg1)
}

// DescribePrincipalIdFormatPagesWithContext mocks base method.
func (m *MockEC2API) DescribePrincipalIdFormatPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePrincipalIdFormatPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribePrincipalIdFormatRequest mocks base method.
func (m *MockEC2API) DescribePrincipalIdFormatRequest(arg0 *ec2.DescribePrincipalIdFormatInput) (*request.Request, *ec2.DescribePrincipalIdFormatOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePrincipalIdFormatRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribePrincipalIdFormatOutput)
	return ret0, ret1
}

// DescribePrincipalIdFormatRequest indicates an expected call of DescribePrincipalIdFormatRequest.
func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatRequest), arg0)
}

// DescribePrincipalIdFormatWithContext mocks base method.
func (m *MockEC2API) DescribePrincipalIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 ...request.Option) (*ec2.DescribePrincipalIdFormatOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePrincipalIdFormatWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribePublicIpv4Pools mocks base method.
func (m *MockEC2API) DescribePublicIpv4Pools(arg0 *ec2.DescribePublicIpv4PoolsInput) (*ec2.DescribePublicIpv4PoolsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePublicIpv4Pools", arg0)
	ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribePublicIpv4Pools indicates an expected call of DescribePublicIpv4Pools.
func (mr *MockEC2APIMockRecorder) DescribePublicIpv4Pools(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4Pools", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4Pools), arg0)
}

// DescribePublicIpv4PoolsPages mocks base method.
func (m *MockEC2API) DescribePublicIpv4PoolsPages(arg0 *ec2.DescribePublicIpv4PoolsInput, arg1 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribePublicIpv4PoolsPages indicates an expected call of DescribePublicIpv4PoolsPages.
func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsPages), arg0, arg1)
}

// DescribePublicIpv4PoolsPagesWithContext mocks base method.
func (m *MockEC2API) DescribePublicIpv4PoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribePublicIpv4PoolsRequest mocks base method.
func (m *MockEC2API) DescribePublicIpv4PoolsRequest(arg0 *ec2.DescribePublicIpv4PoolsInput) (*request.Request, *ec2.DescribePublicIpv4PoolsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribePublicIpv4PoolsOutput)
	return ret0, ret1
}

// DescribePublicIpv4PoolsRequest indicates an expected call of DescribePublicIpv4PoolsRequest.
func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsRequest), arg0)
}

// DescribePublicIpv4PoolsWithContext mocks base method.
func (m *MockEC2API) DescribePublicIpv4PoolsWithContext(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 ...request.Option) (*ec2.DescribePublicIpv4PoolsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRegions mocks base method.
func (m *MockEC2API) DescribeRegions(arg0 *ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRegions", arg0)
	ret0, _ := ret[0].(*ec2.DescribeRegionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeRegions indicates an expected call of DescribeRegions.
func (mr *MockEC2APIMockRecorder) DescribeRegions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegions", reflect.TypeOf((*MockEC2API)(nil).DescribeRegions), arg0)
}

// DescribeRegionsRequest mocks base method.
func (m *MockEC2API) DescribeRegionsRequest(arg0 *ec2.DescribeRegionsInput) (*request.Request, *ec2.DescribeRegionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRegionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeRegionsOutput)
	return ret0, ret1
}

// DescribeRegionsRequest indicates an expected call of DescribeRegionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeRegionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsRequest), arg0)
}

// DescribeRegionsWithContext mocks base method.
func (m *MockEC2API) DescribeRegionsWithContext(arg0 context.Context, arg1 *ec2.DescribeRegionsInput, arg2 ...request.Option) (*ec2.DescribeRegionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeRegionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeRegionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeReplaceRootVolumeTasks mocks base method.
func (m *MockEC2API) DescribeReplaceRootVolumeTasks(arg0 *ec2.DescribeReplaceRootVolumeTasksInput) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeReplaceRootVolumeTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReplaceRootVolumeTasks indicates an expected call of DescribeReplaceRootVolumeTasks.
func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasks), arg0)
}

// DescribeReplaceRootVolumeTasksPages mocks base method.
func (m *MockEC2API) DescribeReplaceRootVolumeTasksPages(arg0 *ec2.DescribeReplaceRootVolumeTasksInput, arg1 func(*ec2.DescribeReplaceRootVolumeTasksOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReplaceRootVolumeTasksPages indicates an expected call of DescribeReplaceRootVolumeTasksPages.
func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksPages), arg0, arg1)
}

// DescribeReplaceRootVolumeTasksPagesWithContext mocks base method.
func (m *MockEC2API) DescribeReplaceRootVolumeTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReplaceRootVolumeTasksInput, arg2 func(*ec2.DescribeReplaceRootVolumeTasksOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeReplaceRootVolumeTasksRequest mocks base method.
func (m *MockEC2API) DescribeReplaceRootVolumeTasksRequest(arg0 *ec2.DescribeReplaceRootVolumeTasksInput) (*request.Request, *ec2.DescribeReplaceRootVolumeTasksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeReplaceRootVolumeTasksOutput)
	return ret0, ret1
}

// DescribeReplaceRootVolumeTasksRequest indicates an expected call of DescribeReplaceRootVolumeTasksRequest.
func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksRequest), arg0)
}

// DescribeReplaceRootVolumeTasksWithContext mocks base method.
func (m *MockEC2API) DescribeReplaceRootVolumeTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeReplaceRootVolumeTasksInput, arg2 ...request.Option) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeReplaceRootVolumeTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeReservedInstances mocks base method.
func (m *MockEC2API) DescribeReservedInstances(arg0 *ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstances", arg0)
	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReservedInstances indicates an expected call of DescribeReservedInstances.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstances), arg0)
}

// DescribeReservedInstancesListings mocks base method.
func (m *MockEC2API) DescribeReservedInstancesListings(arg0 *ec2.DescribeReservedInstancesListingsInput) (*ec2.DescribeReservedInstancesListingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesListings", arg0)
	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReservedInstancesListings indicates an expected call of DescribeReservedInstancesListings.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListings), arg0)
}

// DescribeReservedInstancesListingsRequest mocks base method.
func (m *MockEC2API) DescribeReservedInstancesListingsRequest(arg0 *ec2.DescribeReservedInstancesListingsInput) (*request.Request, *ec2.DescribeReservedInstancesListingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeReservedInstancesListingsOutput)
	return ret0, ret1
}

// DescribeReservedInstancesListingsRequest indicates an expected call of DescribeReservedInstancesListingsRequest.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListingsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListingsRequest), arg0)
}

// DescribeReservedInstancesListingsWithContext mocks base method.
func (m *MockEC2API) DescribeReservedInstancesListingsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesListingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesListingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeReservedInstancesModifications mocks base method.
func (m *MockEC2API) DescribeReservedInstancesModifications(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*ec2.DescribeReservedInstancesModificationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesModifications", arg0)
	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReservedInstancesModifications indicates an expected call of DescribeReservedInstancesModifications.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModifications(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModifications), arg0)
}

// DescribeReservedInstancesModificationsPages mocks base method.
func (m *MockEC2API) DescribeReservedInstancesModificationsPages(arg0 *ec2.DescribeReservedInstancesModificationsInput, arg1 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReservedInstancesModificationsPages indicates an expected call of DescribeReservedInstancesModificationsPages.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsPages), arg0, arg1)
}

// DescribeReservedInstancesModificationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeReservedInstancesModificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeReservedInstancesModificationsRequest mocks base method.
func (m *MockEC2API) DescribeReservedInstancesModificationsRequest(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*request.Request, *ec2.DescribeReservedInstancesModificationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeReservedInstancesModificationsOutput)
	return ret0, ret1
}

// DescribeReservedInstancesModificationsRequest indicates an expected call of DescribeReservedInstancesModificationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsRequest), arg0)
}

// DescribeReservedInstancesModificationsWithContext mocks base method.
func (m *MockEC2API) DescribeReservedInstancesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesModificationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeReservedInstancesOfferings mocks base method.
func (m *MockEC2API) DescribeReservedInstancesOfferings(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*ec2.DescribeReservedInstancesOfferingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferings", arg0)
	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReservedInstancesOfferings indicates an expected call of DescribeReservedInstancesOfferings.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferings), arg0)
}

// DescribeReservedInstancesOfferingsPages mocks base method.
func (m *MockEC2API) DescribeReservedInstancesOfferingsPages(arg0 *ec2.DescribeReservedInstancesOfferingsInput, arg1 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReservedInstancesOfferingsPages indicates an expected call of DescribeReservedInstancesOfferingsPages.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPages), arg0, arg1)
}

// DescribeReservedInstancesOfferingsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeReservedInstancesOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeReservedInstancesOfferingsRequest mocks base method.
func (m *MockEC2API) DescribeReservedInstancesOfferingsRequest(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*request.Request, *ec2.DescribeReservedInstancesOfferingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOfferingsOutput)
	return ret0, ret1
}

// DescribeReservedInstancesOfferingsRequest indicates an expected call of DescribeReservedInstancesOfferingsRequest.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsRequest), arg0)
}

// DescribeReservedInstancesOfferingsWithContext mocks base method.
func (m *MockEC2API) DescribeReservedInstancesOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOfferingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeReservedInstancesRequest mocks base method.
func (m *MockEC2API) DescribeReservedInstancesRequest(arg0 *ec2.DescribeReservedInstancesInput) (*request.Request, *ec2.DescribeReservedInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeReservedInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOutput)
	return ret0, ret1
}

// DescribeReservedInstancesRequest indicates an expected call of DescribeReservedInstancesRequest.
func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesRequest), arg0)
}

// DescribeReservedInstancesWithContext mocks base method.
func (m *MockEC2API) DescribeReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeRouteTables mocks base method.
func (m *MockEC2API) DescribeRouteTables(arg0 *ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRouteTables", arg0)
	ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeRouteTables indicates an expected call of DescribeRouteTables.
func (mr *MockEC2APIMockRecorder) DescribeRouteTables(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTables), arg0)
}

// DescribeRouteTablesPages mocks base method.
func (m *MockEC2API) DescribeRouteTablesPages(arg0 *ec2.DescribeRouteTablesInput, arg1 func(*ec2.DescribeRouteTablesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRouteTablesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeRouteTablesPages indicates an expected call of DescribeRouteTablesPages.
func (mr *MockEC2APIMockRecorder) DescribeRouteTablesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesPages), arg0, arg1)
}

// DescribeRouteTablesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 func(*ec2.DescribeRouteTablesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeRouteTablesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeRouteTablesRequest mocks base method.
func (m *MockEC2API) DescribeRouteTablesRequest(arg0 *ec2.DescribeRouteTablesInput) (*request.Request, *ec2.DescribeRouteTablesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRouteTablesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeRouteTablesOutput)
	return ret0, ret1
}

// DescribeRouteTablesRequest indicates an expected call of DescribeRouteTablesRequest.
func (mr *MockEC2APIMockRecorder) DescribeRouteTablesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesRequest), arg0)
}

// DescribeRouteTablesWithContext mocks base method.
func (m *MockEC2API) DescribeRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeRouteTablesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeRouteTablesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeScheduledInstanceAvailability mocks base method.
func (m *MockEC2API) DescribeScheduledInstanceAvailability(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailability", arg0)
	ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeScheduledInstanceAvailability indicates an expected call of DescribeScheduledInstanceAvailability.
func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailability(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailability", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailability), arg0)
}

// DescribeScheduledInstanceAvailabilityPages mocks base method.
func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPages(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput, arg1 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeScheduledInstanceAvailabilityPages indicates an expected call of DescribeScheduledInstanceAvailabilityPages.
func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPages), arg0, arg1)
}

// DescribeScheduledInstanceAvailabilityPagesWithContext mocks base method.
func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeScheduledInstanceAvailabilityRequest mocks base method.
func (m *MockEC2API) DescribeScheduledInstanceAvailabilityRequest(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*request.Request, *ec2.DescribeScheduledInstanceAvailabilityOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeScheduledInstanceAvailabilityOutput)
	return ret0, ret1
}

// DescribeScheduledInstanceAvailabilityRequest indicates an expected call of DescribeScheduledInstanceAvailabilityRequest.
func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityRequest), arg0)
}

// DescribeScheduledInstanceAvailabilityWithContext mocks base method.
func (m *MockEC2API) DescribeScheduledInstanceAvailabilityWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeScheduledInstances mocks base method.
func (m *MockEC2API) DescribeScheduledInstances(arg0 *ec2.DescribeScheduledInstancesInput) (*ec2.DescribeScheduledInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScheduledInstances", arg0)
	ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeScheduledInstances indicates an expected call of DescribeScheduledInstances.
func (mr *MockEC2APIMockRecorder) DescribeScheduledInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstances), arg0)
}

// DescribeScheduledInstancesPages mocks base method.
func (m *MockEC2API) DescribeScheduledInstancesPages(arg0 *ec2.DescribeScheduledInstancesInput, arg1 func(*ec2.DescribeScheduledInstancesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScheduledInstancesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeScheduledInstancesPages indicates an expected call of DescribeScheduledInstancesPages.
func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesPages), arg0, arg1)
}

// DescribeScheduledInstancesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeScheduledInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 func(*ec2.DescribeScheduledInstancesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeScheduledInstancesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeScheduledInstancesRequest mocks base method.
func (m *MockEC2API) DescribeScheduledInstancesRequest(arg0 *ec2.DescribeScheduledInstancesInput) (*request.Request, *ec2.DescribeScheduledInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeScheduledInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeScheduledInstancesOutput)
	return ret0, ret1
}

// DescribeScheduledInstancesRequest indicates an expected call of DescribeScheduledInstancesRequest.
func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesRequest), arg0)
}

// DescribeScheduledInstancesWithContext mocks base method.
func (m *MockEC2API) DescribeScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeScheduledInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSecurityGroupReferences mocks base method.
func (m *MockEC2API) DescribeSecurityGroupReferences(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*ec2.DescribeSecurityGroupReferencesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupReferences", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSecurityGroupReferences indicates an expected call of DescribeSecurityGroupReferences.
func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferences(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferences", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferences), arg0)
}

// DescribeSecurityGroupReferencesRequest mocks base method.
func (m *MockEC2API) DescribeSecurityGroupReferencesRequest(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*request.Request, *ec2.DescribeSecurityGroupReferencesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSecurityGroupReferencesOutput)
	return ret0, ret1
}

// DescribeSecurityGroupReferencesRequest indicates an expected call of DescribeSecurityGroupReferencesRequest.
func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferencesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferencesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferencesRequest), arg0)
}

// DescribeSecurityGroupReferencesWithContext mocks base method.
func (m *MockEC2API) DescribeSecurityGroupReferencesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupReferencesInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupReferencesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSecurityGroupRules mocks base method.
func (m *MockEC2API) DescribeSecurityGroupRules(arg0 *ec2.DescribeSecurityGroupRulesInput) (*ec2.DescribeSecurityGroupRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupRules", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSecurityGroupRules indicates an expected call of DescribeSecurityGroupRules.
func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupRules(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRules", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupRules), arg0)
}

// DescribeSecurityGroupRulesPages mocks base method.
func (m *MockEC2API) DescribeSecurityGroupRulesPages(arg0 *ec2.DescribeSecurityGroupRulesInput, arg1 func(*ec2.DescribeSecurityGroupRulesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSecurityGroupRulesPages indicates an expected call of DescribeSecurityGroupRulesPages.
func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupRulesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRulesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupRulesPages), arg0, arg1)
}

// DescribeSecurityGroupRulesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeSecurityGroupRulesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupRulesInput, arg2 func(*ec2.DescribeSecurityGroupRulesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSecurityGroupRulesRequest mocks base method.
func (m *MockEC2API) DescribeSecurityGroupRulesRequest(arg0 *ec2.DescribeSecurityGroupRulesInput) (*request.Request, *ec2.DescribeSecurityGroupRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSecurityGroupRulesOutput)
	return ret0, ret1
}

// DescribeSecurityGroupRulesRequest indicates an expected call of DescribeSecurityGroupRulesRequest.
func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupRulesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupRulesRequest), arg0)
}

// DescribeSecurityGroupRulesWithContext mocks base method.
func (m *MockEC2API) DescribeSecurityGroupRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupRulesInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupRulesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSecurityGroups mocks base method.
func (m *MockEC2API) DescribeSecurityGroups(arg0 *ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroups", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSecurityGroups indicates an expected call of DescribeSecurityGroups.
func (mr *MockEC2APIMockRecorder) DescribeSecurityGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroups), arg0)
}

// DescribeSecurityGroupsPages mocks base method.
func (m *MockEC2API) DescribeSecurityGroupsPages(arg0 *ec2.DescribeSecurityGroupsInput, arg1 func(*ec2.DescribeSecurityGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSecurityGroupsPages indicates an expected call of DescribeSecurityGroupsPages.
func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsPages), arg0, arg1)
}

// DescribeSecurityGroupsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 func(*ec2.DescribeSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSecurityGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSecurityGroupsRequest mocks base method.
func (m *MockEC2API) DescribeSecurityGroupsRequest(arg0 *ec2.DescribeSecurityGroupsInput) (*request.Request, *ec2.DescribeSecurityGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSecurityGroupsOutput)
	return ret0, ret1
}

// DescribeSecurityGroupsRequest indicates an expected call of DescribeSecurityGroupsRequest.
func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsRequest), arg0)
}

// DescribeSecurityGroupsWithContext mocks base method.
func (m *MockEC2API) DescribeSecurityGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSecurityGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSnapshotAttribute mocks base method.
func (m *MockEC2API) DescribeSnapshotAttribute(arg0 *ec2.DescribeSnapshotAttributeInput) (*ec2.DescribeSnapshotAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSnapshotAttribute", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSnapshotAttribute indicates an expected call of DescribeSnapshotAttribute.
func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttribute), arg0)
}

// DescribeSnapshotAttributeRequest mocks base method.
func (m *MockEC2API) DescribeSnapshotAttributeRequest(arg0 *ec2.DescribeSnapshotAttributeInput) (*request.Request, *ec2.DescribeSnapshotAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSnapshotAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSnapshotAttributeOutput)
	return ret0, ret1
}

// DescribeSnapshotAttributeRequest indicates an expected call of DescribeSnapshotAttributeRequest.
func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttributeRequest), arg0)
}

// DescribeSnapshotAttributeWithContext mocks base method.
func (m *MockEC2API) DescribeSnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotAttributeInput, arg2 ...request.Option) (*ec2.DescribeSnapshotAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSnapshotAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSnapshotTierStatus mocks base method.
func (m *MockEC2API) DescribeSnapshotTierStatus(arg0 *ec2.DescribeSnapshotTierStatusInput) (*ec2.DescribeSnapshotTierStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatus", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSnapshotTierStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSnapshotTierStatus indicates an expected call of DescribeSnapshotTierStatus.
func (mr *MockEC2APIMockRecorder) DescribeSnapshotTierStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotTierStatus), arg0)
}

// DescribeSnapshotTierStatusPages mocks base method.
func (m *MockEC2API) DescribeSnapshotTierStatusPages(arg0 *ec2.DescribeSnapshotTierStatusInput, arg1 func(*ec2.DescribeSnapshotTierStatusOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSnapshotTierStatusPages indicates an expected call of DescribeSnapshotTierStatusPages.
func (mr *MockEC2APIMockRecorder) DescribeSnapshotTierStatusPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotTierStatusPages), arg0, arg1)
}

// DescribeSnapshotTierStatusPagesWithContext mocks base method.
func (m *MockEC2API) DescribeSnapshotTierStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotTierStatusInput, arg2 func(*ec2.DescribeSnapshotTierStatusOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSnapshotTierStatusRequest mocks base method.
func (m *MockEC2API) DescribeSnapshotTierStatusRequest(arg0 *ec2.DescribeSnapshotTierStatusInput) (*request.Request, *ec2.DescribeSnapshotTierStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSnapshotTierStatusOutput)
	return ret0, ret1
}

// DescribeSnapshotTierStatusRequest indicates an expected call of DescribeSnapshotTierStatusRequest.
func (mr *MockEC2APIMockRecorder) DescribeSnapshotTierStatusRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotTierStatusRequest), arg0)
}

// DescribeSnapshotTierStatusWithContext mocks base method.
func (m *MockEC2API) DescribeSnapshotTierStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotTierStatusInput, arg2 ...request.Option) (*ec2.DescribeSnapshotTierStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSnapshotTierStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSnapshots mocks base method.
func (m *MockEC2API) DescribeSnapshots(arg0 *ec2.DescribeSnapshotsInput) (*ec2.DescribeSnapshotsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSnapshots", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSnapshots indicates an expected call of DescribeSnapshots.
func (mr *MockEC2APIMockRecorder) DescribeSnapshots(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshots", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshots), arg0)
}

// DescribeSnapshotsPages mocks base method.
func (m *MockEC2API) DescribeSnapshotsPages(arg0 *ec2.DescribeSnapshotsInput, arg1 func(*ec2.DescribeSnapshotsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSnapshotsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSnapshotsPages indicates an expected call of DescribeSnapshotsPages.
func (mr *MockEC2APIMockRecorder) DescribeSnapshotsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsPages), arg0, arg1)
}

// DescribeSnapshotsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeSnapshotsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 func(*ec2.DescribeSnapshotsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSnapshotsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSnapshotsRequest mocks base method.
func (m *MockEC2API) DescribeSnapshotsRequest(arg0 *ec2.DescribeSnapshotsInput) (*request.Request, *ec2.DescribeSnapshotsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSnapshotsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSnapshotsOutput)
	return ret0, ret1
}

// DescribeSnapshotsRequest indicates an expected call of DescribeSnapshotsRequest.
func (mr *MockEC2APIMockRecorder) DescribeSnapshotsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsRequest), arg0)
}

// DescribeSnapshotsWithContext mocks base method.
func (m *MockEC2API) DescribeSnapshotsWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeSnapshotsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSnapshotsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSpotDatafeedSubscription mocks base method.
func (m *MockEC2API) DescribeSpotDatafeedSubscription(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscription", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSpotDatafeedSubscription indicates an expected call of DescribeSpotDatafeedSubscription.
func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscription(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscription), arg0)
}

// DescribeSpotDatafeedSubscriptionRequest mocks base method.
func (m *MockEC2API) DescribeSpotDatafeedSubscriptionRequest(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSpotDatafeedSubscriptionOutput)
	return ret0, ret1
}

// DescribeSpotDatafeedSubscriptionRequest indicates an expected call of DescribeSpotDatafeedSubscriptionRequest.
func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionRequest), arg0)
}

// DescribeSpotDatafeedSubscriptionWithContext mocks base method.
func (m *MockEC2API) DescribeSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSpotFleetInstances mocks base method.
func (m *MockEC2API) DescribeSpotFleetInstances(arg0 *ec2.DescribeSpotFleetInstancesInput) (*ec2.DescribeSpotFleetInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotFleetInstances", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSpotFleetInstances indicates an expected call of DescribeSpotFleetInstances.
func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstances), arg0)
}

// DescribeSpotFleetInstancesRequest mocks base method.
func (m *MockEC2API) DescribeSpotFleetInstancesRequest(arg0 *ec2.DescribeSpotFleetInstancesInput) (*request.Request, *ec2.DescribeSpotFleetInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSpotFleetInstancesOutput)
	return ret0, ret1
}

// DescribeSpotFleetInstancesRequest indicates an expected call of DescribeSpotFleetInstancesRequest.
func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstancesRequest), arg0)
}

// DescribeSpotFleetInstancesWithContext mocks base method.
func (m *MockEC2API) DescribeSpotFleetInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSpotFleetRequestHistory mocks base method.
func (m *MockEC2API) DescribeSpotFleetRequestHistory(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistory", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSpotFleetRequestHistory indicates an expected call of DescribeSpotFleetRequestHistory.
func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistory(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistory), arg0)
}

// DescribeSpotFleetRequestHistoryRequest mocks base method.
func (m *MockEC2API) DescribeSpotFleetRequestHistoryRequest(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*request.Request, *ec2.DescribeSpotFleetRequestHistoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestHistoryOutput)
	return ret0, ret1
}

// DescribeSpotFleetRequestHistoryRequest indicates an expected call of DescribeSpotFleetRequestHistoryRequest.
func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistoryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryRequest), arg0)
}

// DescribeSpotFleetRequestHistoryWithContext mocks base method.
func (m *MockEC2API) DescribeSpotFleetRequestHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSpotFleetRequests mocks base method.
func (m *MockEC2API) DescribeSpotFleetRequests(arg0 *ec2.DescribeSpotFleetRequestsInput) (*ec2.DescribeSpotFleetRequestsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotFleetRequests", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSpotFleetRequests indicates an expected call of DescribeSpotFleetRequests.
func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequests(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequests), arg0)
}

// DescribeSpotFleetRequestsPages mocks base method.
func (m *MockEC2API) DescribeSpotFleetRequestsPages(arg0 *ec2.DescribeSpotFleetRequestsInput, arg1 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSpotFleetRequestsPages indicates an expected call of DescribeSpotFleetRequestsPages.
func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsPages), arg0, arg1)
}

// DescribeSpotFleetRequestsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeSpotFleetRequestsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSpotFleetRequestsRequest mocks base method.
func (m *MockEC2API) DescribeSpotFleetRequestsRequest(arg0 *ec2.DescribeSpotFleetRequestsInput) (*request.Request, *ec2.DescribeSpotFleetRequestsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestsOutput)
	return ret0, ret1
}

// DescribeSpotFleetRequestsRequest indicates an expected call of DescribeSpotFleetRequestsRequest.
func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsRequest), arg0)
}

// DescribeSpotFleetRequestsWithContext mocks base method.
func (m *MockEC2API) DescribeSpotFleetRequestsWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSpotInstanceRequests mocks base method.
func (m *MockEC2API) DescribeSpotInstanceRequests(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*ec2.DescribeSpotInstanceRequestsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequests", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSpotInstanceRequests indicates an expected call of DescribeSpotInstanceRequests.
func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequests(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequests), arg0)
}

// DescribeSpotInstanceRequestsPages mocks base method.
func (m *MockEC2API) DescribeSpotInstanceRequestsPages(arg0 *ec2.DescribeSpotInstanceRequestsInput, arg1 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSpotInstanceRequestsPages indicates an expected call of DescribeSpotInstanceRequestsPages.
func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsPages), arg0, arg1)
}

// DescribeSpotInstanceRequestsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeSpotInstanceRequestsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSpotInstanceRequestsRequest mocks base method.
func (m *MockEC2API) DescribeSpotInstanceRequestsRequest(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*request.Request, *ec2.DescribeSpotInstanceRequestsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSpotInstanceRequestsOutput)
	return ret0, ret1
}

// DescribeSpotInstanceRequestsRequest indicates an expected call of DescribeSpotInstanceRequestsRequest.
func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsRequest), arg0)
}

// DescribeSpotInstanceRequestsWithContext mocks base method.
func (m *MockEC2API) DescribeSpotInstanceRequestsWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotInstanceRequestsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSpotPriceHistory mocks base method.
func (m *MockEC2API) DescribeSpotPriceHistory(arg0 *ec2.DescribeSpotPriceHistoryInput) (*ec2.DescribeSpotPriceHistoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotPriceHistory", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSpotPriceHistory indicates an expected call of DescribeSpotPriceHistory.
func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistory(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistory), arg0)
}

// DescribeSpotPriceHistoryPages mocks base method.
func (m *MockEC2API) DescribeSpotPriceHistoryPages(arg0 *ec2.DescribeSpotPriceHistoryInput, arg1 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSpotPriceHistoryPages indicates an expected call of DescribeSpotPriceHistoryPages.
func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryPages), arg0, arg1)
}

// DescribeSpotPriceHistoryPagesWithContext mocks base method.
func (m *MockEC2API) DescribeSpotPriceHistoryPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSpotPriceHistoryRequest mocks base method.
func (m *MockEC2API) DescribeSpotPriceHistoryRequest(arg0 *ec2.DescribeSpotPriceHistoryInput) (*request.Request, *ec2.DescribeSpotPriceHistoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSpotPriceHistoryOutput)
	return ret0, ret1
}

// DescribeSpotPriceHistoryRequest indicates an expected call of DescribeSpotPriceHistoryRequest.
func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryRequest), arg0)
}

// DescribeSpotPriceHistoryWithContext mocks base method.
func (m *MockEC2API) DescribeSpotPriceHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotPriceHistoryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeStaleSecurityGroups mocks base method.
func (m *MockEC2API) DescribeStaleSecurityGroups(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*ec2.DescribeStaleSecurityGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroups", arg0)
	ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeStaleSecurityGroups indicates an expected call of DescribeStaleSecurityGroups.
func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroups), arg0)
}

// DescribeStaleSecurityGroupsPages mocks base method.
func (m *MockEC2API) DescribeStaleSecurityGroupsPages(arg0 *ec2.DescribeStaleSecurityGroupsInput, arg1 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeStaleSecurityGroupsPages indicates an expected call of DescribeStaleSecurityGroupsPages.
func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsPages), arg0, arg1)
}

// DescribeStaleSecurityGroupsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeStaleSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeStaleSecurityGroupsRequest mocks base method.
func (m *MockEC2API) DescribeStaleSecurityGroupsRequest(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*request.Request, *ec2.DescribeStaleSecurityGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeStaleSecurityGroupsOutput)
	return ret0, ret1
}

// DescribeStaleSecurityGroupsRequest indicates an expected call of DescribeStaleSecurityGroupsRequest.
func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsRequest), arg0)
}

// DescribeStaleSecurityGroupsWithContext mocks base method.
func (m *MockEC2API) DescribeStaleSecurityGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeStaleSecurityGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeStoreImageTasks mocks base method.
func (m *MockEC2API) DescribeStoreImageTasks(arg0 *ec2.DescribeStoreImageTasksInput) (*ec2.DescribeStoreImageTasksOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStoreImageTasks", arg0)
	ret0, _ := ret[0].(*ec2.DescribeStoreImageTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeStoreImageTasks indicates an expected call of DescribeStoreImageTasks.
func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasks), arg0)
}

// DescribeStoreImageTasksPages mocks base method.
func (m *MockEC2API) DescribeStoreImageTasksPages(arg0 *ec2.DescribeStoreImageTasksInput, arg1 func(*ec2.DescribeStoreImageTasksOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStoreImageTasksPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeStoreImageTasksPages indicates an expected call of DescribeStoreImageTasksPages.
func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksPages), arg0, arg1)
}

// DescribeStoreImageTasksPagesWithContext mocks base method.
func (m *MockEC2API) DescribeStoreImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeStoreImageTasksInput, arg2 func(*ec2.DescribeStoreImageTasksOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeStoreImageTasksPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeStoreImageTasksRequest mocks base method.
func (m *MockEC2API) DescribeStoreImageTasksRequest(arg0 *ec2.DescribeStoreImageTasksInput) (*request.Request, *ec2.DescribeStoreImageTasksOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeStoreImageTasksRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeStoreImageTasksOutput)
	return ret0, ret1
}

// DescribeStoreImageTasksRequest indicates an expected call of DescribeStoreImageTasksRequest.
func (mr *MockEC2APIMockRecorder) DescribeStoreImageTasksRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeStoreImageTasksRequest), arg0)
}

// DescribeStoreImageTasksWithContext mocks base method.
func (m *MockEC2API) DescribeStoreImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeStoreImageTasksInput, arg2 ...request.Option) (*ec2.DescribeStoreImageTasksOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeStoreImageTasksWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeStoreImageTasksOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeSubnets mocks base method.
func (m *MockEC2API) DescribeSubnets(arg0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSubnets", arg0)
	ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSubnets indicates an expected call of DescribeSubnets.
func (mr *MockEC2APIMockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnets), arg0)
}

// DescribeSubnetsPages mocks base method.
func (m *MockEC2API) DescribeSubnetsPages(arg0 *ec2.DescribeSubnetsInput, arg1 func(*ec2.DescribeSubnetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSubnetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSubnetsPages indicates an expected call of DescribeSubnetsPages.
func (mr *MockEC2APIMockRecorder) DescribeSubnetsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPages), arg0, arg1)
}

// DescribeSubnetsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeSubnetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 func(*ec2.DescribeSubnetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSubnetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeSubnetsRequest mocks base method.
func (m *MockEC2API) DescribeSubnetsRequest(arg0 *ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSubnetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeSubnetsOutput)
	return ret0, ret1
}

// DescribeSubnetsRequest indicates an expected call of DescribeSubnetsRequest.
func (mr *MockEC2APIMockRecorder) DescribeSubnetsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsRequest), arg0)
}

// DescribeSubnetsWithContext mocks base method.
func (m *MockEC2API) DescribeSubnetsWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.Option) (*ec2.DescribeSubnetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSubnetsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTags mocks base method.
func (m *MockEC2API) DescribeTags(arg0 *ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTags", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTags indicates an expected call of DescribeTags.
func (mr *MockEC2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockEC2API)(nil).DescribeTags), arg0)
}

// DescribeTagsPages mocks base method.
func (m *MockEC2API) DescribeTagsPages(arg0 *ec2.DescribeTagsInput, arg1 func(*ec2.DescribeTagsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTagsPages indicates an expected call of DescribeTagsPages.
func (mr *MockEC2APIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPages), arg0, arg1)
}

// DescribeTagsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTagsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTagsInput, arg2 func(*ec2.DescribeTagsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTagsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTagsRequest mocks base method.
func (m *MockEC2API) DescribeTagsRequest(arg0 *ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTagsOutput)
	return ret0, ret1
}

// DescribeTagsRequest indicates an expected call of DescribeTagsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsRequest), arg0)
}

// DescribeTagsWithContext mocks base method.
func (m *MockEC2API) DescribeTagsWithContext(arg0 context.Context, arg1 *ec2.DescribeTagsInput, arg2 ...request.Option) (*ec2.DescribeTagsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTagsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTrafficMirrorFilterRules mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorFilterRules(arg0 *ec2.DescribeTrafficMirrorFilterRulesInput) (*ec2.DescribeTrafficMirrorFilterRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilterRules", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFilterRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTrafficMirrorFilterRules indicates an expected call of DescribeTrafficMirrorFilterRules.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilterRules(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilterRules", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilterRules), arg0)
}

// DescribeTrafficMirrorFilterRulesRequest mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorFilterRulesRequest(arg0 *ec2.DescribeTrafficMirrorFilterRulesInput) (*request.Request, *ec2.DescribeTrafficMirrorFilterRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilterRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorFilterRulesOutput)
	return ret0, ret1
}

// DescribeTrafficMirrorFilterRulesRequest indicates an expected call of DescribeTrafficMirrorFilterRulesRequest.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilterRulesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilterRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilterRulesRequest), arg0)
}

// DescribeTrafficMirrorFilterRulesWithContext mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorFilterRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFilterRulesInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorFilterRulesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilterRulesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFilterRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTrafficMirrorFilters mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorFilters(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*ec2.DescribeTrafficMirrorFiltersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilters", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTrafficMirrorFilters indicates an expected call of DescribeTrafficMirrorFilters.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilters(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilters", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilters), arg0)
}

// DescribeTrafficMirrorFiltersPages mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorFiltersPages(arg0 *ec2.DescribeTrafficMirrorFiltersInput, arg1 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTrafficMirrorFiltersPages indicates an expected call of DescribeTrafficMirrorFiltersPages.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPages), arg0, arg1)
}

// DescribeTrafficMirrorFiltersPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorFiltersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTrafficMirrorFiltersRequest mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorFiltersRequest(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*request.Request, *ec2.DescribeTrafficMirrorFiltersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorFiltersOutput)
	return ret0, ret1
}

// DescribeTrafficMirrorFiltersRequest indicates an expected call of DescribeTrafficMirrorFiltersRequest.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersRequest), arg0)
}

// DescribeTrafficMirrorFiltersWithContext mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorFiltersWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorFiltersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTrafficMirrorSessions mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorSessions(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*ec2.DescribeTrafficMirrorSessionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessions", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTrafficMirrorSessions indicates an expected call of DescribeTrafficMirrorSessions.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessions", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessions), arg0)
}

// DescribeTrafficMirrorSessionsPages mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorSessionsPages(arg0 *ec2.DescribeTrafficMirrorSessionsInput, arg1 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTrafficMirrorSessionsPages indicates an expected call of DescribeTrafficMirrorSessionsPages.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPages), arg0, arg1)
}

// DescribeTrafficMirrorSessionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorSessionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTrafficMirrorSessionsRequest mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorSessionsRequest(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*request.Request, *ec2.DescribeTrafficMirrorSessionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorSessionsOutput)
	return ret0, ret1
}

// DescribeTrafficMirrorSessionsRequest indicates an expected call of DescribeTrafficMirrorSessionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsRequest), arg0)
}

// DescribeTrafficMirrorSessionsWithContext mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorSessionsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorSessionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTrafficMirrorTargets mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorTargets(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*ec2.DescribeTrafficMirrorTargetsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargets", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTrafficMirrorTargets indicates an expected call of DescribeTrafficMirrorTargets.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargets", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargets), arg0)
}

// DescribeTrafficMirrorTargetsPages mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorTargetsPages(arg0 *ec2.DescribeTrafficMirrorTargetsInput, arg1 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTrafficMirrorTargetsPages indicates an expected call of DescribeTrafficMirrorTargetsPages.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPages), arg0, arg1)
}

// DescribeTrafficMirrorTargetsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorTargetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTrafficMirrorTargetsRequest mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorTargetsRequest(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*request.Request, *ec2.DescribeTrafficMirrorTargetsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorTargetsOutput)
	return ret0, ret1
}

// DescribeTrafficMirrorTargetsRequest indicates an expected call of DescribeTrafficMirrorTargetsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsRequest), arg0)
}

// DescribeTrafficMirrorTargetsWithContext mocks base method.
func (m *MockEC2API) DescribeTrafficMirrorTargetsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorTargetsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayAttachments mocks base method.
func (m *MockEC2API) DescribeTransitGatewayAttachments(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachments", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayAttachments indicates an expected call of DescribeTransitGatewayAttachments.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachments(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachments), arg0)
}

// DescribeTransitGatewayAttachmentsPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayAttachmentsPages(arg0 *ec2.DescribeTransitGatewayAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayAttachmentsPages indicates an expected call of DescribeTransitGatewayAttachmentsPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPages), arg0, arg1)
}

// DescribeTransitGatewayAttachmentsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayAttachmentsRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayAttachmentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayAttachmentsOutput)
	return ret0, ret1
}

// DescribeTransitGatewayAttachmentsRequest indicates an expected call of DescribeTransitGatewayAttachmentsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsRequest), arg0)
}

// DescribeTransitGatewayAttachmentsWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayConnectPeers mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectPeers(arg0 *ec2.DescribeTransitGatewayConnectPeersInput) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeers", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectPeersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayConnectPeers indicates an expected call of DescribeTransitGatewayConnectPeers.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeers", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeers), arg0)
}

// DescribeTransitGatewayConnectPeersPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectPeersPages(arg0 *ec2.DescribeTransitGatewayConnectPeersInput, arg1 func(*ec2.DescribeTransitGatewayConnectPeersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayConnectPeersPages indicates an expected call of DescribeTransitGatewayConnectPeersPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersPages), arg0, arg1)
}

// DescribeTransitGatewayConnectPeersPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectPeersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayConnectPeersInput, arg2 func(*ec2.DescribeTransitGatewayConnectPeersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayConnectPeersRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectPeersRequest(arg0 *ec2.DescribeTransitGatewayConnectPeersInput) (*request.Request, *ec2.DescribeTransitGatewayConnectPeersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayConnectPeersOutput)
	return ret0, ret1
}

// DescribeTransitGatewayConnectPeersRequest indicates an expected call of DescribeTransitGatewayConnectPeersRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectPeersRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectPeersRequest), arg0)
}

// DescribeTransitGatewayConnectPeersWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectPeersWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayConnectPeersInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayConnectPeersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectPeersWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectPeersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayConnects mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnects(arg0 *ec2.DescribeTransitGatewayConnectsInput) (*ec2.DescribeTransitGatewayConnectsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnects", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayConnects indicates an expected call of DescribeTransitGatewayConnects.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnects(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnects", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnects), arg0)
}

// DescribeTransitGatewayConnectsPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectsPages(arg0 *ec2.DescribeTransitGatewayConnectsInput, arg1 func(*ec2.DescribeTransitGatewayConnectsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayConnectsPages indicates an expected call of DescribeTransitGatewayConnectsPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsPages), arg0, arg1)
}

// DescribeTransitGatewayConnectsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayConnectsInput, arg2 func(*ec2.DescribeTransitGatewayConnectsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayConnectsRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectsRequest(arg0 *ec2.DescribeTransitGatewayConnectsInput) (*request.Request, *ec2.DescribeTransitGatewayConnectsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayConnectsOutput)
	return ret0, ret1
}

// DescribeTransitGatewayConnectsRequest indicates an expected call of DescribeTransitGatewayConnectsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayConnectsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayConnectsRequest), arg0)
}

// DescribeTransitGatewayConnectsWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayConnectsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayConnectsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayConnectsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayConnectsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayConnectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayMulticastDomains mocks base method.
func (m *MockEC2API) DescribeTransitGatewayMulticastDomains(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomains", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayMulticastDomains indicates an expected call of DescribeTransitGatewayMulticastDomains.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomains(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomains", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomains), arg0)
}

// DescribeTransitGatewayMulticastDomainsPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsPages(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg1 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayMulticastDomainsPages indicates an expected call of DescribeTransitGatewayMulticastDomainsPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsPages), arg0, arg1)
}

// DescribeTransitGatewayMulticastDomainsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg2 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayMulticastDomainsRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsRequest(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*request.Request, *ec2.DescribeTransitGatewayMulticastDomainsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
	return ret0, ret1
}

// DescribeTransitGatewayMulticastDomainsRequest indicates an expected call of DescribeTransitGatewayMulticastDomainsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsRequest), arg0)
}

// DescribeTransitGatewayMulticastDomainsWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayMulticastDomainsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayPeeringAttachments mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPeeringAttachments(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachments", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayPeeringAttachments indicates an expected call of DescribeTransitGatewayPeeringAttachments.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachments(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachments), arg0)
}

// DescribeTransitGatewayPeeringAttachmentsPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsPages(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayPeeringAttachmentsPages indicates an expected call of DescribeTransitGatewayPeeringAttachmentsPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsPages), arg0, arg1)
}

// DescribeTransitGatewayPeeringAttachmentsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayPeeringAttachmentsRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayPeeringAttachmentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
	return ret0, ret1
}

// DescribeTransitGatewayPeeringAttachmentsRequest indicates an expected call of DescribeTransitGatewayPeeringAttachmentsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsRequest), arg0)
}

// DescribeTransitGatewayPeeringAttachmentsWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayPolicyTables mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPolicyTables(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTables", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPolicyTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayPolicyTables indicates an expected call of DescribeTransitGatewayPolicyTables.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPolicyTables(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTables", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPolicyTables), arg0)
}

// DescribeTransitGatewayPolicyTablesPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPolicyTablesPages(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput, arg1 func(*ec2.DescribeTransitGatewayPolicyTablesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayPolicyTablesPages indicates an expected call of DescribeTransitGatewayPolicyTablesPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPolicyTablesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPolicyTablesPages), arg0, arg1)
}

// DescribeTransitGatewayPolicyTablesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPolicyTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPolicyTablesInput, arg2 func(*ec2.DescribeTransitGatewayPolicyTablesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayPolicyTablesRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPolicyTablesRequest(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput) (*request.Request, *ec2.DescribeTransitGatewayPolicyTablesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayPolicyTablesOutput)
	return ret0, ret1
}

// DescribeTransitGatewayPolicyTablesRequest indicates an expected call of DescribeTransitGatewayPolicyTablesRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPolicyTablesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPolicyTablesRequest), arg0)
}

// DescribeTransitGatewayPolicyTablesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayPolicyTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPolicyTablesInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPolicyTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayRouteTableAnnouncements mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncements(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncements", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayRouteTableAnnouncements indicates an expected call of DescribeTransitGatewayRouteTableAnnouncements.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTableAnnouncements(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncements", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTableAnnouncements), arg0)
}

// DescribeTransitGatewayRouteTableAnnouncementsPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncementsPages(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg1 func(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayRouteTableAnnouncementsPages indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTableAnnouncementsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncementsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTableAnnouncementsPages), arg0, arg1)
}

// DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg2 func(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayRouteTableAnnouncementsRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncementsRequest(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput)
	return ret0, ret1
}

// DescribeTransitGatewayRouteTableAnnouncementsRequest indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTableAnnouncementsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncementsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTableAnnouncementsRequest), arg0)
}

// DescribeTransitGatewayRouteTableAnnouncementsWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTableAnnouncementsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayRouteTables mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTables(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTables", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayRouteTables indicates an expected call of DescribeTransitGatewayRouteTables.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTables(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTables), arg0)
}

// DescribeTransitGatewayRouteTablesPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTablesPages(arg0 *ec2.DescribeTransitGatewayRouteTablesInput, arg1 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayRouteTablesPages indicates an expected call of DescribeTransitGatewayRouteTablesPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPages), arg0, arg1)
}

// DescribeTransitGatewayRouteTablesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayRouteTablesRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTablesRequest(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTablesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayRouteTablesOutput)
	return ret0, ret1
}

// DescribeTransitGatewayRouteTablesRequest indicates an expected call of DescribeTransitGatewayRouteTablesRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesRequest), arg0)
}

// DescribeTransitGatewayRouteTablesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGatewayVpcAttachments mocks base method.
func (m *MockEC2API) DescribeTransitGatewayVpcAttachments(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachments", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGatewayVpcAttachments indicates an expected call of DescribeTransitGatewayVpcAttachments.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachments(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachments), arg0)
}

// DescribeTransitGatewayVpcAttachmentsPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPages(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewayVpcAttachmentsPages indicates an expected call of DescribeTransitGatewayVpcAttachmentsPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPages), arg0, arg1)
}

// DescribeTransitGatewayVpcAttachmentsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewayVpcAttachmentsRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayVpcAttachmentsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
	return ret0, ret1
}

// DescribeTransitGatewayVpcAttachmentsRequest indicates an expected call of DescribeTransitGatewayVpcAttachmentsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsRequest), arg0)
}

// DescribeTransitGatewayVpcAttachmentsWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTransitGateways mocks base method.
func (m *MockEC2API) DescribeTransitGateways(arg0 *ec2.DescribeTransitGatewaysInput) (*ec2.DescribeTransitGatewaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGateways", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTransitGateways indicates an expected call of DescribeTransitGateways.
func (mr *MockEC2APIMockRecorder) DescribeTransitGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGateways), arg0)
}

// DescribeTransitGatewaysPages mocks base method.
func (m *MockEC2API) DescribeTransitGatewaysPages(arg0 *ec2.DescribeTransitGatewaysInput, arg1 func(*ec2.DescribeTransitGatewaysOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewaysPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTransitGatewaysPages indicates an expected call of DescribeTransitGatewaysPages.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysPages), arg0, arg1)
}

// DescribeTransitGatewaysPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 func(*ec2.DescribeTransitGatewaysOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewaysPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTransitGatewaysRequest mocks base method.
func (m *MockEC2API) DescribeTransitGatewaysRequest(arg0 *ec2.DescribeTransitGatewaysInput) (*request.Request, *ec2.DescribeTransitGatewaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTransitGatewaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTransitGatewaysOutput)
	return ret0, ret1
}

// DescribeTransitGatewaysRequest indicates an expected call of DescribeTransitGatewaysRequest.
func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysRequest), arg0)
}

// DescribeTransitGatewaysWithContext mocks base method.
func (m *MockEC2API) DescribeTransitGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewaysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTransitGatewaysWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTrunkInterfaceAssociations mocks base method.
func (m *MockEC2API) DescribeTrunkInterfaceAssociations(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeTrunkInterfaceAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTrunkInterfaceAssociations indicates an expected call of DescribeTrunkInterfaceAssociations.
func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociations), arg0)
}

// DescribeTrunkInterfaceAssociationsPages mocks base method.
func (m *MockEC2API) DescribeTrunkInterfaceAssociationsPages(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput, arg1 func(*ec2.DescribeTrunkInterfaceAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeTrunkInterfaceAssociationsPages indicates an expected call of DescribeTrunkInterfaceAssociationsPages.
func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociationsPages), arg0, arg1)
}

// DescribeTrunkInterfaceAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeTrunkInterfaceAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrunkInterfaceAssociationsInput, arg2 func(*ec2.DescribeTrunkInterfaceAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeTrunkInterfaceAssociationsRequest mocks base method.
func (m *MockEC2API) DescribeTrunkInterfaceAssociationsRequest(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*request.Request, *ec2.DescribeTrunkInterfaceAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeTrunkInterfaceAssociationsOutput)
	return ret0, ret1
}

// DescribeTrunkInterfaceAssociationsRequest indicates an expected call of DescribeTrunkInterfaceAssociationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeTrunkInterfaceAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrunkInterfaceAssociationsRequest), arg0)
}

// DescribeTrunkInterfaceAssociationsWithContext mocks base method.
func (m *MockEC2API) DescribeTrunkInterfaceAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrunkInterfaceAssociationsInput, arg2 ...request.Option) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeTrunkInterfaceAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVerifiedAccessEndpoints mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessEndpoints(arg0 *ec2.DescribeVerifiedAccessEndpointsInput) (*ec2.DescribeVerifiedAccessEndpointsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpoints", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVerifiedAccessEndpoints indicates an expected call of DescribeVerifiedAccessEndpoints.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessEndpoints), arg0)
}

// DescribeVerifiedAccessEndpointsPages mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessEndpointsPages(arg0 *ec2.DescribeVerifiedAccessEndpointsInput, arg1 func(*ec2.DescribeVerifiedAccessEndpointsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVerifiedAccessEndpointsPages indicates an expected call of DescribeVerifiedAccessEndpointsPages.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessEndpointsPages), arg0, arg1)
}

// DescribeVerifiedAccessEndpointsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessEndpointsInput, arg2 func(*ec2.DescribeVerifiedAccessEndpointsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVerifiedAccessEndpointsRequest mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessEndpointsRequest(arg0 *ec2.DescribeVerifiedAccessEndpointsInput) (*request.Request, *ec2.DescribeVerifiedAccessEndpointsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessEndpointsOutput)
	return ret0, ret1
}

// DescribeVerifiedAccessEndpointsRequest indicates an expected call of DescribeVerifiedAccessEndpointsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessEndpointsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessEndpointsRequest), arg0)
}

// DescribeVerifiedAccessEndpointsWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessEndpointsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessEndpointsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVerifiedAccessGroups mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessGroups(arg0 *ec2.DescribeVerifiedAccessGroupsInput) (*ec2.DescribeVerifiedAccessGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroups", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVerifiedAccessGroups indicates an expected call of DescribeVerifiedAccessGroups.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessGroups), arg0)
}

// DescribeVerifiedAccessGroupsPages mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessGroupsPages(arg0 *ec2.DescribeVerifiedAccessGroupsInput, arg1 func(*ec2.DescribeVerifiedAccessGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVerifiedAccessGroupsPages indicates an expected call of DescribeVerifiedAccessGroupsPages.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessGroupsPages), arg0, arg1)
}

// DescribeVerifiedAccessGroupsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessGroupsInput, arg2 func(*ec2.DescribeVerifiedAccessGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVerifiedAccessGroupsRequest mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessGroupsRequest(arg0 *ec2.DescribeVerifiedAccessGroupsInput) (*request.Request, *ec2.DescribeVerifiedAccessGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessGroupsOutput)
	return ret0, ret1
}

// DescribeVerifiedAccessGroupsRequest indicates an expected call of DescribeVerifiedAccessGroupsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessGroupsRequest), arg0)
}

// DescribeVerifiedAccessGroupsWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessGroupsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVerifiedAccessInstanceLoggingConfigurations mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurations(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVerifiedAccessInstanceLoggingConfigurations indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurations.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurations", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstanceLoggingConfigurations), arg0)
}

// DescribeVerifiedAccessInstanceLoggingConfigurationsPages mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurationsPages(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg1 func(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVerifiedAccessInstanceLoggingConfigurationsPages indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsPages.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsPages), arg0, arg1)
}

// DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg2 func(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVerifiedAccessInstanceLoggingConfigurationsRequest mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurationsRequest(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput) (*request.Request, *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput)
	return ret0, ret1
}

// DescribeVerifiedAccessInstanceLoggingConfigurationsRequest indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsRequest), arg0)
}

// DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVerifiedAccessInstances mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstances(arg0 *ec2.DescribeVerifiedAccessInstancesInput) (*ec2.DescribeVerifiedAccessInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstances", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVerifiedAccessInstances indicates an expected call of DescribeVerifiedAccessInstances.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstances), arg0)
}

// DescribeVerifiedAccessInstancesPages mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstancesPages(arg0 *ec2.DescribeVerifiedAccessInstancesInput, arg1 func(*ec2.DescribeVerifiedAccessInstancesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVerifiedAccessInstancesPages indicates an expected call of DescribeVerifiedAccessInstancesPages.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstancesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstancesPages), arg0, arg1)
}

// DescribeVerifiedAccessInstancesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstancesInput, arg2 func(*ec2.DescribeVerifiedAccessInstancesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVerifiedAccessInstancesRequest mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstancesRequest(arg0 *ec2.DescribeVerifiedAccessInstancesInput) (*request.Request, *ec2.DescribeVerifiedAccessInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessInstancesOutput)
	return ret0, ret1
}

// DescribeVerifiedAccessInstancesRequest indicates an expected call of DescribeVerifiedAccessInstancesRequest.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessInstancesRequest), arg0)
}

// DescribeVerifiedAccessInstancesWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstancesInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVerifiedAccessTrustProviders mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessTrustProviders(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProviders", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessTrustProvidersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVerifiedAccessTrustProviders indicates an expected call of DescribeVerifiedAccessTrustProviders.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessTrustProviders(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProviders", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessTrustProviders), arg0)
}

// DescribeVerifiedAccessTrustProvidersPages mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessTrustProvidersPages(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg1 func(*ec2.DescribeVerifiedAccessTrustProvidersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVerifiedAccessTrustProvidersPages indicates an expected call of DescribeVerifiedAccessTrustProvidersPages.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessTrustProvidersPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProvidersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessTrustProvidersPages), arg0, arg1)
}

// DescribeVerifiedAccessTrustProvidersPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessTrustProvidersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg2 func(*ec2.DescribeVerifiedAccessTrustProvidersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVerifiedAccessTrustProvidersRequest mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessTrustProvidersRequest(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput) (*request.Request, *ec2.DescribeVerifiedAccessTrustProvidersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessTrustProvidersOutput)
	return ret0, ret1
}

// DescribeVerifiedAccessTrustProvidersRequest indicates an expected call of DescribeVerifiedAccessTrustProvidersRequest.
func (mr *MockEC2APIMockRecorder) DescribeVerifiedAccessTrustProvidersRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProvidersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVerifiedAccessTrustProvidersRequest), arg0)
}

// DescribeVerifiedAccessTrustProvidersWithContext mocks base method.
func (m *MockEC2API) DescribeVerifiedAccessTrustProvidersWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessTrustProvidersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVolumeAttribute mocks base method.
func (m *MockEC2API) DescribeVolumeAttribute(arg0 *ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumeAttribute", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVolumeAttribute indicates an expected call of DescribeVolumeAttribute.
func (mr *MockEC2APIMockRecorder) DescribeVolumeAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttribute), arg0)
}

// DescribeVolumeAttributeRequest mocks base method.
func (m *MockEC2API) DescribeVolumeAttributeRequest(arg0 *ec2.DescribeVolumeAttributeInput) (*request.Request, *ec2.DescribeVolumeAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumeAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVolumeAttributeOutput)
	return ret0, ret1
}

// DescribeVolumeAttributeRequest indicates an expected call of DescribeVolumeAttributeRequest.
func (mr *MockEC2APIMockRecorder) DescribeVolumeAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttributeRequest), arg0)
}

// DescribeVolumeAttributeWithContext mocks base method.
func (m *MockEC2API) DescribeVolumeAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeAttributeInput, arg2 ...request.Option) (*ec2.DescribeVolumeAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVolumeAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVolumeStatus mocks base method.
func (m *MockEC2API) DescribeVolumeStatus(arg0 *ec2.DescribeVolumeStatusInput) (*ec2.DescribeVolumeStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumeStatus", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVolumeStatus indicates an expected call of DescribeVolumeStatus.
func (mr *MockEC2APIMockRecorder) DescribeVolumeStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatus), arg0)
}

// DescribeVolumeStatusPages mocks base method.
func (m *MockEC2API) DescribeVolumeStatusPages(arg0 *ec2.DescribeVolumeStatusInput, arg1 func(*ec2.DescribeVolumeStatusOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumeStatusPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVolumeStatusPages indicates an expected call of DescribeVolumeStatusPages.
func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusPages), arg0, arg1)
}

// DescribeVolumeStatusPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVolumeStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 func(*ec2.DescribeVolumeStatusOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVolumeStatusPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVolumeStatusRequest mocks base method.
func (m *MockEC2API) DescribeVolumeStatusRequest(arg0 *ec2.DescribeVolumeStatusInput) (*request.Request, *ec2.DescribeVolumeStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumeStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVolumeStatusOutput)
	return ret0, ret1
}

// DescribeVolumeStatusRequest indicates an expected call of DescribeVolumeStatusRequest.
func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusRequest), arg0)
}

// DescribeVolumeStatusWithContext mocks base method.
func (m *MockEC2API) DescribeVolumeStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 ...request.Option) (*ec2.DescribeVolumeStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVolumeStatusWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVolumes mocks base method.
func (m *MockEC2API) DescribeVolumes(arg0 *ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumes", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVolumesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVolumes indicates an expected call of DescribeVolumes.
func (mr *MockEC2APIMockRecorder) DescribeVolumes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumes", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumes), arg0)
}

// DescribeVolumesModifications mocks base method.
func (m *MockEC2API) DescribeVolumesModifications(arg0 *ec2.DescribeVolumesModificationsInput) (*ec2.DescribeVolumesModificationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumesModifications", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVolumesModifications indicates an expected call of DescribeVolumesModifications.
func (mr *MockEC2APIMockRecorder) DescribeVolumesModifications(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModifications), arg0)
}

// DescribeVolumesModificationsPages mocks base method.
func (m *MockEC2API) DescribeVolumesModificationsPages(arg0 *ec2.DescribeVolumesModificationsInput, arg1 func(*ec2.DescribeVolumesModificationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumesModificationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVolumesModificationsPages indicates an expected call of DescribeVolumesModificationsPages.
func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsPages), arg0, arg1)
}

// DescribeVolumesModificationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVolumesModificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 func(*ec2.DescribeVolumesModificationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVolumesModificationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVolumesModificationsRequest mocks base method.
func (m *MockEC2API) DescribeVolumesModificationsRequest(arg0 *ec2.DescribeVolumesModificationsInput) (*request.Request, *ec2.DescribeVolumesModificationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumesModificationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVolumesModificationsOutput)
	return ret0, ret1
}

// DescribeVolumesModificationsRequest indicates an expected call of DescribeVolumesModificationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsRequest), arg0)
}

// DescribeVolumesModificationsWithContext mocks base method.
func (m *MockEC2API) DescribeVolumesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVolumesModificationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVolumesPages mocks base method.
func (m *MockEC2API) DescribeVolumesPages(arg0 *ec2.DescribeVolumesInput, arg1 func(*ec2.DescribeVolumesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVolumesPages indicates an expected call of DescribeVolumesPages.
func (mr *MockEC2APIMockRecorder) DescribeVolumesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesPages), arg0, arg1)
}

// DescribeVolumesPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVolumesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 func(*ec2.DescribeVolumesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVolumesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVolumesRequest mocks base method.
func (m *MockEC2API) DescribeVolumesRequest(arg0 *ec2.DescribeVolumesInput) (*request.Request, *ec2.DescribeVolumesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVolumesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVolumesOutput)
	return ret0, ret1
}

// DescribeVolumesRequest indicates an expected call of DescribeVolumesRequest.
func (mr *MockEC2APIMockRecorder) DescribeVolumesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesRequest), arg0)
}

// DescribeVolumesWithContext mocks base method.
func (m *MockEC2API) DescribeVolumesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.Option) (*ec2.DescribeVolumesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVolumesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVolumesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcAttribute mocks base method.
func (m *MockEC2API) DescribeVpcAttribute(arg0 *ec2.DescribeVpcAttributeInput) (*ec2.DescribeVpcAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcAttribute", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcAttribute indicates an expected call of DescribeVpcAttribute.
func (mr *MockEC2APIMockRecorder) DescribeVpcAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttribute), arg0)
}

// DescribeVpcAttributeRequest mocks base method.
func (m *MockEC2API) DescribeVpcAttributeRequest(arg0 *ec2.DescribeVpcAttributeInput) (*request.Request, *ec2.DescribeVpcAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcAttributeOutput)
	return ret0, ret1
}

// DescribeVpcAttributeRequest indicates an expected call of DescribeVpcAttributeRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttributeRequest), arg0)
}

// DescribeVpcAttributeWithContext mocks base method.
func (m *MockEC2API) DescribeVpcAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcAttributeInput, arg2 ...request.Option) (*ec2.DescribeVpcAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcClassicLink mocks base method.
func (m *MockEC2API) DescribeVpcClassicLink(arg0 *ec2.DescribeVpcClassicLinkInput) (*ec2.DescribeVpcClassicLinkOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcClassicLink", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcClassicLink indicates an expected call of DescribeVpcClassicLink.
func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLink(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLink), arg0)
}

// DescribeVpcClassicLinkDnsSupport mocks base method.
func (m *MockEC2API) DescribeVpcClassicLinkDnsSupport(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupport", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcClassicLinkDnsSupport indicates an expected call of DescribeVpcClassicLinkDnsSupport.
func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupport), arg0)
}

// DescribeVpcClassicLinkDnsSupportPages mocks base method.
func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPages(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg1 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVpcClassicLinkDnsSupportPages indicates an expected call of DescribeVpcClassicLinkDnsSupportPages.
func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPages), arg0, arg1)
}

// DescribeVpcClassicLinkDnsSupportPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVpcClassicLinkDnsSupportRequest mocks base method.
func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportRequest(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DescribeVpcClassicLinkDnsSupportOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
	return ret0, ret1
}

// DescribeVpcClassicLinkDnsSupportRequest indicates an expected call of DescribeVpcClassicLinkDnsSupportRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportRequest), arg0)
}

// DescribeVpcClassicLinkDnsSupportWithContext mocks base method.
func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcClassicLinkRequest mocks base method.
func (m *MockEC2API) DescribeVpcClassicLinkRequest(arg0 *ec2.DescribeVpcClassicLinkInput) (*request.Request, *ec2.DescribeVpcClassicLinkOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkOutput)
	return ret0, ret1
}

// DescribeVpcClassicLinkRequest indicates an expected call of DescribeVpcClassicLinkRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkRequest), arg0)
}

// DescribeVpcClassicLinkWithContext mocks base method.
func (m *MockEC2API) DescribeVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcClassicLinkWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcEndpointConnectionNotifications mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionNotifications(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotifications", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcEndpointConnectionNotifications indicates an expected call of DescribeVpcEndpointConnectionNotifications.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotifications), arg0)
}

// DescribeVpcEndpointConnectionNotificationsPages mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPages(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVpcEndpointConnectionNotificationsPages indicates an expected call of DescribeVpcEndpointConnectionNotificationsPages.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPages), arg0, arg1)
}

// DescribeVpcEndpointConnectionNotificationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVpcEndpointConnectionNotificationsRequest mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionNotificationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
	return ret0, ret1
}

// DescribeVpcEndpointConnectionNotificationsRequest indicates an expected call of DescribeVpcEndpointConnectionNotificationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsRequest), arg0)
}

// DescribeVpcEndpointConnectionNotificationsWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcEndpointConnections mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnections(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*ec2.DescribeVpcEndpointConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnections", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcEndpointConnections indicates an expected call of DescribeVpcEndpointConnections.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnections(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnections), arg0)
}

// DescribeVpcEndpointConnectionsPages mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionsPages(arg0 *ec2.DescribeVpcEndpointConnectionsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVpcEndpointConnectionsPages indicates an expected call of DescribeVpcEndpointConnectionsPages.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPages), arg0, arg1)
}

// DescribeVpcEndpointConnectionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVpcEndpointConnectionsRequest mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionsRequest(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionsOutput)
	return ret0, ret1
}

// DescribeVpcEndpointConnectionsRequest indicates an expected call of DescribeVpcEndpointConnectionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsRequest), arg0)
}

// DescribeVpcEndpointConnectionsWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcEndpointServiceConfigurations mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServiceConfigurations(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurations", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcEndpointServiceConfigurations indicates an expected call of DescribeVpcEndpointServiceConfigurations.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurations), arg0)
}

// DescribeVpcEndpointServiceConfigurationsPages mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPages(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg1 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVpcEndpointServiceConfigurationsPages indicates an expected call of DescribeVpcEndpointServiceConfigurationsPages.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPages), arg0, arg1)
}

// DescribeVpcEndpointServiceConfigurationsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVpcEndpointServiceConfigurationsRequest mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DescribeVpcEndpointServiceConfigurationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
	return ret0, ret1
}

// DescribeVpcEndpointServiceConfigurationsRequest indicates an expected call of DescribeVpcEndpointServiceConfigurationsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsRequest), arg0)
}

// DescribeVpcEndpointServiceConfigurationsWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcEndpointServicePermissions mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServicePermissions(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissions", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcEndpointServicePermissions indicates an expected call of DescribeVpcEndpointServicePermissions.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissions), arg0)
}

// DescribeVpcEndpointServicePermissionsPages mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPages(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput, arg1 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVpcEndpointServicePermissionsPages indicates an expected call of DescribeVpcEndpointServicePermissionsPages.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPages), arg0, arg1)
}

// DescribeVpcEndpointServicePermissionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVpcEndpointServicePermissionsRequest mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServicePermissionsRequest(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*request.Request, *ec2.DescribeVpcEndpointServicePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicePermissionsOutput)
	return ret0, ret1
}

// DescribeVpcEndpointServicePermissionsRequest indicates an expected call of DescribeVpcEndpointServicePermissionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsRequest), arg0)
}

// DescribeVpcEndpointServicePermissionsWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServicePermissionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcEndpointServices mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServices(arg0 *ec2.DescribeVpcEndpointServicesInput) (*ec2.DescribeVpcEndpointServicesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServices", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcEndpointServices indicates an expected call of DescribeVpcEndpointServices.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServices(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServices", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServices), arg0)
}

// DescribeVpcEndpointServicesRequest mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServicesRequest(arg0 *ec2.DescribeVpcEndpointServicesInput) (*request.Request, *ec2.DescribeVpcEndpointServicesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicesOutput)
	return ret0, ret1
}

// DescribeVpcEndpointServicesRequest indicates an expected call of DescribeVpcEndpointServicesRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicesRequest), arg0)
}

// DescribeVpcEndpointServicesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointServicesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicesInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcEndpoints mocks base method.
func (m *MockEC2API) DescribeVpcEndpoints(arg0 *ec2.DescribeVpcEndpointsInput) (*ec2.DescribeVpcEndpointsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpoints", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcEndpoints indicates an expected call of DescribeVpcEndpoints.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpoints), arg0)
}

// DescribeVpcEndpointsPages mocks base method.
func (m *MockEC2API) DescribeVpcEndpointsPages(arg0 *ec2.DescribeVpcEndpointsInput, arg1 func(*ec2.DescribeVpcEndpointsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVpcEndpointsPages indicates an expected call of DescribeVpcEndpointsPages.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPages), arg0, arg1)
}

// DescribeVpcEndpointsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 func(*ec2.DescribeVpcEndpointsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVpcEndpointsRequest mocks base method.
func (m *MockEC2API) DescribeVpcEndpointsRequest(arg0 *ec2.DescribeVpcEndpointsInput) (*request.Request, *ec2.DescribeVpcEndpointsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcEndpointsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointsOutput)
	return ret0, ret1
}

// DescribeVpcEndpointsRequest indicates an expected call of DescribeVpcEndpointsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsRequest), arg0)
}

// DescribeVpcEndpointsWithContext mocks base method.
func (m *MockEC2API) DescribeVpcEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcEndpointsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcPeeringConnections mocks base method.
func (m *MockEC2API) DescribeVpcPeeringConnections(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*ec2.DescribeVpcPeeringConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnections", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcPeeringConnections indicates an expected call of DescribeVpcPeeringConnections.
func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnections(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnections), arg0)
}

// DescribeVpcPeeringConnectionsPages mocks base method.
func (m *MockEC2API) DescribeVpcPeeringConnectionsPages(arg0 *ec2.DescribeVpcPeeringConnectionsInput, arg1 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVpcPeeringConnectionsPages indicates an expected call of DescribeVpcPeeringConnectionsPages.
func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPages), arg0, arg1)
}

// DescribeVpcPeeringConnectionsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcPeeringConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVpcPeeringConnectionsRequest mocks base method.
func (m *MockEC2API) DescribeVpcPeeringConnectionsRequest(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*request.Request, *ec2.DescribeVpcPeeringConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcPeeringConnectionsOutput)
	return ret0, ret1
}

// DescribeVpcPeeringConnectionsRequest indicates an expected call of DescribeVpcPeeringConnectionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsRequest), arg0)
}

// DescribeVpcPeeringConnectionsWithContext mocks base method.
func (m *MockEC2API) DescribeVpcPeeringConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcPeeringConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpcs mocks base method.
func (m *MockEC2API) DescribeVpcs(arg0 *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcs", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpcsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcs indicates an expected call of DescribeVpcs.
func (mr *MockEC2APIMockRecorder) DescribeVpcs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcs", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcs), arg0)
}

// DescribeVpcsPages mocks base method.
func (m *MockEC2API) DescribeVpcsPages(arg0 *ec2.DescribeVpcsInput, arg1 func(*ec2.DescribeVpcsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeVpcsPages indicates an expected call of DescribeVpcsPages.
func (mr *MockEC2APIMockRecorder) DescribeVpcsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsPages), arg0, arg1)
}

// DescribeVpcsPagesWithContext mocks base method.
func (m *MockEC2API) DescribeVpcsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 func(*ec2.DescribeVpcsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeVpcsRequest mocks base method.
func (m *MockEC2API) DescribeVpcsRequest(arg0 *ec2.DescribeVpcsInput) (*request.Request, *ec2.DescribeVpcsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpcsOutput)
	return ret0, ret1
}

// DescribeVpcsRequest indicates an expected call of DescribeVpcsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpcsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsRequest), arg0)
}

// DescribeVpcsWithContext mocks base method.
func (m *MockEC2API) DescribeVpcsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.Option) (*ec2.DescribeVpcsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpcsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpcsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpnConnections mocks base method.
func (m *MockEC2API) DescribeVpnConnections(arg0 *ec2.DescribeVpnConnectionsInput) (*ec2.DescribeVpnConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpnConnections", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpnConnections indicates an expected call of DescribeVpnConnections.
func (mr *MockEC2APIMockRecorder) DescribeVpnConnections(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnections), arg0)
}

// DescribeVpnConnectionsRequest mocks base method.
func (m *MockEC2API) DescribeVpnConnectionsRequest(arg0 *ec2.DescribeVpnConnectionsInput) (*request.Request, *ec2.DescribeVpnConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpnConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpnConnectionsOutput)
	return ret0, ret1
}

// DescribeVpnConnectionsRequest indicates an expected call of DescribeVpnConnectionsRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpnConnectionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnectionsRequest), arg0)
}

// DescribeVpnConnectionsWithContext mocks base method.
func (m *MockEC2API) DescribeVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpnConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpnConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeVpnGateways mocks base method.
func (m *MockEC2API) DescribeVpnGateways(arg0 *ec2.DescribeVpnGatewaysInput) (*ec2.DescribeVpnGatewaysOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpnGateways", arg0)
	ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpnGateways indicates an expected call of DescribeVpnGateways.
func (mr *MockEC2APIMockRecorder) DescribeVpnGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGateways), arg0)
}

// DescribeVpnGatewaysRequest mocks base method.
func (m *MockEC2API) DescribeVpnGatewaysRequest(arg0 *ec2.DescribeVpnGatewaysInput) (*request.Request, *ec2.DescribeVpnGatewaysOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpnGatewaysRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DescribeVpnGatewaysOutput)
	return ret0, ret1
}

// DescribeVpnGatewaysRequest indicates an expected call of DescribeVpnGatewaysRequest.
func (mr *MockEC2APIMockRecorder) DescribeVpnGatewaysRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGatewaysRequest), arg0)
}

// DescribeVpnGatewaysWithContext mocks base method.
func (m *MockEC2API) DescribeVpnGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnGatewaysInput, arg2 ...request.Option) (*ec2.DescribeVpnGatewaysOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeVpnGatewaysWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachClassicLinkVpc mocks base method.
func (m *MockEC2API) DetachClassicLinkVpc(arg0 *ec2.DetachClassicLinkVpcInput) (*ec2.DetachClassicLinkVpcOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachClassicLinkVpc", arg0)
	ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachClassicLinkVpc indicates an expected call of DetachClassicLinkVpc.
func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpc), arg0)
}

// DetachClassicLinkVpcRequest mocks base method.
func (m *MockEC2API) DetachClassicLinkVpcRequest(arg0 *ec2.DetachClassicLinkVpcInput) (*request.Request, *ec2.DetachClassicLinkVpcOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachClassicLinkVpcRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DetachClassicLinkVpcOutput)
	return ret0, ret1
}

// DetachClassicLinkVpcRequest indicates an expected call of DetachClassicLinkVpcRequest.
func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpcRequest), arg0)
}

// DetachClassicLinkVpcWithContext mocks base method.
func (m *MockEC2API) DetachClassicLinkVpcWithContext(arg0 context.Context, arg1 *ec2.DetachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.DetachClassicLinkVpcOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DetachClassicLinkVpcWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachInternetGateway mocks base method.
func (m *MockEC2API) DetachInternetGateway(arg0 *ec2.DetachInternetGatewayInput) (*ec2.DetachInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachInternetGateway", arg0)
	ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachInternetGateway indicates an expected call of DetachInternetGateway.
func (mr *MockEC2APIMockRecorder) DetachInternetGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGateway), arg0)
}

// DetachInternetGatewayRequest mocks base method.
func (m *MockEC2API) DetachInternetGatewayRequest(arg0 *ec2.DetachInternetGatewayInput) (*request.Request, *ec2.DetachInternetGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachInternetGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DetachInternetGatewayOutput)
	return ret0, ret1
}

// DetachInternetGatewayRequest indicates an expected call of DetachInternetGatewayRequest.
func (mr *MockEC2APIMockRecorder) DetachInternetGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGatewayRequest), arg0)
}

// DetachInternetGatewayWithContext mocks base method.
func (m *MockEC2API) DetachInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DetachInternetGatewayInput, arg2 ...request.Option) (*ec2.DetachInternetGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DetachInternetGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachNetworkInterface mocks base method.
func (m *MockEC2API) DetachNetworkInterface(arg0 *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachNetworkInterface", arg0)
	ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachNetworkInterface indicates an expected call of DetachNetworkInterface.
func (mr *MockEC2APIMockRecorder) DetachNetworkInterface(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterface), arg0)
}

// DetachNetworkInterfaceRequest mocks base method.
func (m *MockEC2API) DetachNetworkInterfaceRequest(arg0 *ec2.DetachNetworkInterfaceInput) (*request.Request, *ec2.DetachNetworkInterfaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachNetworkInterfaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DetachNetworkInterfaceOutput)
	return ret0, ret1
}

// DetachNetworkInterfaceRequest indicates an expected call of DetachNetworkInterfaceRequest.
func (mr *MockEC2APIMockRecorder) DetachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterfaceRequest), arg0)
}

// DetachNetworkInterfaceWithContext mocks base method.
func (m *MockEC2API) DetachNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DetachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DetachNetworkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DetachNetworkInterfaceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachVerifiedAccessTrustProvider mocks base method.
func (m *MockEC2API) DetachVerifiedAccessTrustProvider(arg0 *ec2.DetachVerifiedAccessTrustProviderInput) (*ec2.DetachVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProvider", arg0)
	ret0, _ := ret[0].(*ec2.DetachVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachVerifiedAccessTrustProvider indicates an expected call of DetachVerifiedAccessTrustProvider.
func (mr *MockEC2APIMockRecorder) DetachVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).DetachVerifiedAccessTrustProvider), arg0)
}

// DetachVerifiedAccessTrustProviderRequest mocks base method.
func (m *MockEC2API) DetachVerifiedAccessTrustProviderRequest(arg0 *ec2.DetachVerifiedAccessTrustProviderInput) (*request.Request, *ec2.DetachVerifiedAccessTrustProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DetachVerifiedAccessTrustProviderOutput)
	return ret0, ret1
}

// DetachVerifiedAccessTrustProviderRequest indicates an expected call of DetachVerifiedAccessTrustProviderRequest.
func (mr *MockEC2APIMockRecorder) DetachVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVerifiedAccessTrustProviderRequest), arg0)
}

// DetachVerifiedAccessTrustProviderWithContext mocks base method.
func (m *MockEC2API) DetachVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.DetachVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.DetachVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProviderWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DetachVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachVolume mocks base method.
func (m *MockEC2API) DetachVolume(arg0 *ec2.DetachVolumeInput) (*ec2.VolumeAttachment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachVolume", arg0)
	ret0, _ := ret[0].(*ec2.VolumeAttachment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachVolume indicates an expected call of DetachVolume.
func (mr *MockEC2APIMockRecorder) DetachVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolume", reflect.TypeOf((*MockEC2API)(nil).DetachVolume), arg0)
}

// DetachVolumeRequest mocks base method.
func (m *MockEC2API) DetachVolumeRequest(arg0 *ec2.DetachVolumeInput) (*request.Request, *ec2.VolumeAttachment) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachVolumeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.VolumeAttachment)
	return ret0, ret1
}

// DetachVolumeRequest indicates an expected call of DetachVolumeRequest.
func (mr *MockEC2APIMockRecorder) DetachVolumeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVolumeRequest), arg0)
}

// DetachVolumeWithContext mocks base method.
func (m *MockEC2API) DetachVolumeWithContext(arg0 context.Context, arg1 *ec2.DetachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DetachVolumeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.VolumeAttachment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachVpnGateway mocks base method.
func (m *MockEC2API) DetachVpnGateway(arg0 *ec2.DetachVpnGatewayInput) (*ec2.DetachVpnGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachVpnGateway", arg0)
	ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachVpnGateway indicates an expected call of DetachVpnGateway.
func (mr *MockEC2APIMockRecorder) DetachVpnGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGateway), arg0)
}

// DetachVpnGatewayRequest mocks base method.
func (m *MockEC2API) DetachVpnGatewayRequest(arg0 *ec2.DetachVpnGatewayInput) (*request.Request, *ec2.DetachVpnGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachVpnGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DetachVpnGatewayOutput)
	return ret0, ret1
}

// DetachVpnGatewayRequest indicates an expected call of DetachVpnGatewayRequest.
func (mr *MockEC2APIMockRecorder) DetachVpnGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGatewayRequest), arg0)
}

// DetachVpnGatewayWithContext mocks base method.
func (m *MockEC2API) DetachVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.DetachVpnGatewayInput, arg2 ...request.Option) (*ec2.DetachVpnGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DetachVpnGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableAddressTransfer mocks base method.
func (m *MockEC2API) DisableAddressTransfer(arg0 *ec2.DisableAddressTransferInput) (*ec2.DisableAddressTransferOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAddressTransfer", arg0)
	ret0, _ := ret[0].(*ec2.DisableAddressTransferOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableAddressTransfer indicates an expected call of DisableAddressTransfer.
func (mr *MockEC2APIMockRecorder) DisableAddressTransfer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAddressTransfer", reflect.TypeOf((*MockEC2API)(nil).DisableAddressTransfer), arg0)
}

// DisableAddressTransferRequest mocks base method.
func (m *MockEC2API) DisableAddressTransferRequest(arg0 *ec2.DisableAddressTransferInput) (*request.Request, *ec2.DisableAddressTransferOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAddressTransferRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableAddressTransferOutput)
	return ret0, ret1
}

// DisableAddressTransferRequest indicates an expected call of DisableAddressTransferRequest.
func (mr *MockEC2APIMockRecorder) DisableAddressTransferRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAddressTransferRequest", reflect.TypeOf((*MockEC2API)(nil).DisableAddressTransferRequest), arg0)
}

// DisableAddressTransferWithContext mocks base method.
func (m *MockEC2API) DisableAddressTransferWithContext(arg0 context.Context, arg1 *ec2.DisableAddressTransferInput, arg2 ...request.Option) (*ec2.DisableAddressTransferOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableAddressTransferWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableAddressTransferOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableAwsNetworkPerformanceMetricSubscription mocks base method.
func (m *MockEC2API) DisableAwsNetworkPerformanceMetricSubscription(arg0 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscription", arg0)
	ret0, _ := ret[0].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableAwsNetworkPerformanceMetricSubscription indicates an expected call of DisableAwsNetworkPerformanceMetricSubscription.
func (mr *MockEC2APIMockRecorder) DisableAwsNetworkPerformanceMetricSubscription(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAwsNetworkPerformanceMetricSubscription", reflect.TypeOf((*MockEC2API)(nil).DisableAwsNetworkPerformanceMetricSubscription), arg0)
}

// DisableAwsNetworkPerformanceMetricSubscriptionRequest mocks base method.
func (m *MockEC2API) DisableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput) (*request.Request, *ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput)
	return ret0, ret1
}

// DisableAwsNetworkPerformanceMetricSubscriptionRequest indicates an expected call of DisableAwsNetworkPerformanceMetricSubscriptionRequest.
func (mr *MockEC2APIMockRecorder) DisableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAwsNetworkPerformanceMetricSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DisableAwsNetworkPerformanceMetricSubscriptionRequest), arg0)
}

// DisableAwsNetworkPerformanceMetricSubscriptionWithContext mocks base method.
func (m *MockEC2API) DisableAwsNetworkPerformanceMetricSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, arg2 ...request.Option) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableEbsEncryptionByDefault mocks base method.
func (m *MockEC2API) DisableEbsEncryptionByDefault(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*ec2.DisableEbsEncryptionByDefaultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefault", arg0)
	ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableEbsEncryptionByDefault indicates an expected call of DisableEbsEncryptionByDefault.
func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefault), arg0)
}

// DisableEbsEncryptionByDefaultRequest mocks base method.
func (m *MockEC2API) DisableEbsEncryptionByDefaultRequest(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*request.Request, *ec2.DisableEbsEncryptionByDefaultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableEbsEncryptionByDefaultOutput)
	return ret0, ret1
}

// DisableEbsEncryptionByDefaultRequest indicates an expected call of DisableEbsEncryptionByDefaultRequest.
func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefaultRequest), arg0)
}

// DisableEbsEncryptionByDefaultWithContext mocks base method.
func (m *MockEC2API) DisableEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.DisableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.DisableEbsEncryptionByDefaultOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableFastLaunch mocks base method.
func (m *MockEC2API) DisableFastLaunch(arg0 *ec2.DisableFastLaunchInput) (*ec2.DisableFastLaunchOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableFastLaunch", arg0)
	ret0, _ := ret[0].(*ec2.DisableFastLaunchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableFastLaunch indicates an expected call of DisableFastLaunch.
func (mr *MockEC2APIMockRecorder) DisableFastLaunch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastLaunch", reflect.TypeOf((*MockEC2API)(nil).DisableFastLaunch), arg0)
}

// DisableFastLaunchRequest mocks base method.
func (m *MockEC2API) DisableFastLaunchRequest(arg0 *ec2.DisableFastLaunchInput) (*request.Request, *ec2.DisableFastLaunchOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableFastLaunchRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableFastLaunchOutput)
	return ret0, ret1
}

// DisableFastLaunchRequest indicates an expected call of DisableFastLaunchRequest.
func (mr *MockEC2APIMockRecorder) DisableFastLaunchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastLaunchRequest", reflect.TypeOf((*MockEC2API)(nil).DisableFastLaunchRequest), arg0)
}

// DisableFastLaunchWithContext mocks base method.
func (m *MockEC2API) DisableFastLaunchWithContext(arg0 context.Context, arg1 *ec2.DisableFastLaunchInput, arg2 ...request.Option) (*ec2.DisableFastLaunchOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableFastLaunchWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableFastLaunchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableFastSnapshotRestores mocks base method.
func (m *MockEC2API) DisableFastSnapshotRestores(arg0 *ec2.DisableFastSnapshotRestoresInput) (*ec2.DisableFastSnapshotRestoresOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableFastSnapshotRestores", arg0)
	ret0, _ := ret[0].(*ec2.DisableFastSnapshotRestoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableFastSnapshotRestores indicates an expected call of DisableFastSnapshotRestores.
func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestores(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestores), arg0)
}

// DisableFastSnapshotRestoresRequest mocks base method.
func (m *MockEC2API) DisableFastSnapshotRestoresRequest(arg0 *ec2.DisableFastSnapshotRestoresInput) (*request.Request, *ec2.DisableFastSnapshotRestoresOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableFastSnapshotRestoresRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableFastSnapshotRestoresOutput)
	return ret0, ret1
}

// DisableFastSnapshotRestoresRequest indicates an expected call of DisableFastSnapshotRestoresRequest.
func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestoresRequest), arg0)
}

// DisableFastSnapshotRestoresWithContext mocks base method.
func (m *MockEC2API) DisableFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.DisableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.DisableFastSnapshotRestoresOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableFastSnapshotRestoresWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableFastSnapshotRestoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableImage mocks base method.
func (m *MockEC2API) DisableImage(arg0 *ec2.DisableImageInput) (*ec2.DisableImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableImage", arg0)
	ret0, _ := ret[0].(*ec2.DisableImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableImage indicates an expected call of DisableImage.
func (mr *MockEC2APIMockRecorder) DisableImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImage", reflect.TypeOf((*MockEC2API)(nil).DisableImage), arg0)
}

// DisableImageBlockPublicAccess mocks base method.
func (m *MockEC2API) DisableImageBlockPublicAccess(arg0 *ec2.DisableImageBlockPublicAccessInput) (*ec2.DisableImageBlockPublicAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableImageBlockPublicAccess", arg0)
	ret0, _ := ret[0].(*ec2.DisableImageBlockPublicAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableImageBlockPublicAccess indicates an expected call of DisableImageBlockPublicAccess.
func (mr *MockEC2APIMockRecorder) DisableImageBlockPublicAccess(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageBlockPublicAccess", reflect.TypeOf((*MockEC2API)(nil).DisableImageBlockPublicAccess), arg0)
}

// DisableImageBlockPublicAccessRequest mocks base method.
func (m *MockEC2API) DisableImageBlockPublicAccessRequest(arg0 *ec2.DisableImageBlockPublicAccessInput) (*request.Request, *ec2.DisableImageBlockPublicAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableImageBlockPublicAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableImageBlockPublicAccessOutput)
	return ret0, ret1
}

// DisableImageBlockPublicAccessRequest indicates an expected call of DisableImageBlockPublicAccessRequest.
func (mr *MockEC2APIMockRecorder) DisableImageBlockPublicAccessRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageBlockPublicAccessRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageBlockPublicAccessRequest), arg0)
}

// DisableImageBlockPublicAccessWithContext mocks base method.
func (m *MockEC2API) DisableImageBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.DisableImageBlockPublicAccessInput, arg2 ...request.Option) (*ec2.DisableImageBlockPublicAccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableImageBlockPublicAccessWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableImageBlockPublicAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableImageDeprecation mocks base method.
func (m *MockEC2API) DisableImageDeprecation(arg0 *ec2.DisableImageDeprecationInput) (*ec2.DisableImageDeprecationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableImageDeprecation", arg0)
	ret0, _ := ret[0].(*ec2.DisableImageDeprecationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableImageDeprecation indicates an expected call of DisableImageDeprecation.
func (mr *MockEC2APIMockRecorder) DisableImageDeprecation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecation", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecation), arg0)
}

// DisableImageDeprecationRequest mocks base method.
func (m *MockEC2API) DisableImageDeprecationRequest(arg0 *ec2.DisableImageDeprecationInput) (*request.Request, *ec2.DisableImageDeprecationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableImageDeprecationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableImageDeprecationOutput)
	return ret0, ret1
}

// DisableImageDeprecationRequest indicates an expected call of DisableImageDeprecationRequest.
func (mr *MockEC2APIMockRecorder) DisableImageDeprecationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeprecationRequest), arg0)
}

// DisableImageDeprecationWithContext mocks base method.
func (m *MockEC2API) DisableImageDeprecationWithContext(arg0 context.Context, arg1 *ec2.DisableImageDeprecationInput, arg2 ...request.Option) (*ec2.DisableImageDeprecationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableImageDeprecationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableImageDeprecationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableImageDeregistrationProtection mocks base method.
func (m *MockEC2API) DisableImageDeregistrationProtection(arg0 *ec2.DisableImageDeregistrationProtectionInput) (*ec2.DisableImageDeregistrationProtectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableImageDeregistrationProtection", arg0)
	ret0, _ := ret[0].(*ec2.DisableImageDeregistrationProtectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableImageDeregistrationProtection indicates an expected call of DisableImageDeregistrationProtection.
func (mr *MockEC2APIMockRecorder) DisableImageDeregistrationProtection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeregistrationProtection", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeregistrationProtection), arg0)
}

// DisableImageDeregistrationProtectionRequest mocks base method.
func (m *MockEC2API) DisableImageDeregistrationProtectionRequest(arg0 *ec2.DisableImageDeregistrationProtectionInput) (*request.Request, *ec2.DisableImageDeregistrationProtectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableImageDeregistrationProtectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableImageDeregistrationProtectionOutput)
	return ret0, ret1
}

// DisableImageDeregistrationProtectionRequest indicates an expected call of DisableImageDeregistrationProtectionRequest.
func (mr *MockEC2APIMockRecorder) DisableImageDeregistrationProtectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeregistrationProtectionRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageDeregistrationProtectionRequest), arg0)
}

// DisableImageDeregistrationProtectionWithContext mocks base method.
func (m *MockEC2API) DisableImageDeregistrationProtectionWithContext(arg0 context.Context, arg1 *ec2.DisableImageDeregistrationProtectionInput, arg2 ...request.Option) (*ec2.DisableImageDeregistrationProtectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableImageDeregistrationProtectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableImageDeregistrationProtectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableImageRequest mocks base method.
func (m *MockEC2API) DisableImageRequest(arg0 *ec2.DisableImageInput) (*request.Request, *ec2.DisableImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableImageOutput)
	return ret0, ret1
}

// DisableImageRequest indicates an expected call of DisableImageRequest.
func (mr *MockEC2APIMockRecorder) DisableImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageRequest", reflect.TypeOf((*MockEC2API)(nil).DisableImageRequest), arg0)
}

// DisableImageWithContext mocks base method.
func (m *MockEC2API) DisableImageWithContext(arg0 context.Context, arg1 *ec2.DisableImageInput, arg2 ...request.Option) (*ec2.DisableImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableIpamOrganizationAdminAccount mocks base method.
func (m *MockEC2API) DisableIpamOrganizationAdminAccount(arg0 *ec2.DisableIpamOrganizationAdminAccountInput) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccount", arg0)
	ret0, _ := ret[0].(*ec2.DisableIpamOrganizationAdminAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableIpamOrganizationAdminAccount indicates an expected call of DisableIpamOrganizationAdminAccount.
func (mr *MockEC2APIMockRecorder) DisableIpamOrganizationAdminAccount(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableIpamOrganizationAdminAccount", reflect.TypeOf((*MockEC2API)(nil).DisableIpamOrganizationAdminAccount), arg0)
}

// DisableIpamOrganizationAdminAccountRequest mocks base method.
func (m *MockEC2API) DisableIpamOrganizationAdminAccountRequest(arg0 *ec2.DisableIpamOrganizationAdminAccountInput) (*request.Request, *ec2.DisableIpamOrganizationAdminAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableIpamOrganizationAdminAccountOutput)
	return ret0, ret1
}

// DisableIpamOrganizationAdminAccountRequest indicates an expected call of DisableIpamOrganizationAdminAccountRequest.
func (mr *MockEC2APIMockRecorder) DisableIpamOrganizationAdminAccountRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableIpamOrganizationAdminAccountRequest", reflect.TypeOf((*MockEC2API)(nil).DisableIpamOrganizationAdminAccountRequest), arg0)
}

// DisableIpamOrganizationAdminAccountWithContext mocks base method.
func (m *MockEC2API) DisableIpamOrganizationAdminAccountWithContext(arg0 context.Context, arg1 *ec2.DisableIpamOrganizationAdminAccountInput, arg2 ...request.Option) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccountWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableIpamOrganizationAdminAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableSerialConsoleAccess mocks base method.
func (m *MockEC2API) DisableSerialConsoleAccess(arg0 *ec2.DisableSerialConsoleAccessInput) (*ec2.DisableSerialConsoleAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableSerialConsoleAccess", arg0)
	ret0, _ := ret[0].(*ec2.DisableSerialConsoleAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableSerialConsoleAccess indicates an expected call of DisableSerialConsoleAccess.
func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccess(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccess", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccess), arg0)
}

// DisableSerialConsoleAccessRequest mocks base method.
func (m *MockEC2API) DisableSerialConsoleAccessRequest(arg0 *ec2.DisableSerialConsoleAccessInput) (*request.Request, *ec2.DisableSerialConsoleAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableSerialConsoleAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableSerialConsoleAccessOutput)
	return ret0, ret1
}

// DisableSerialConsoleAccessRequest indicates an expected call of DisableSerialConsoleAccessRequest.
func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccessRequest), arg0)
}

// DisableSerialConsoleAccessWithContext mocks base method.
func (m *MockEC2API) DisableSerialConsoleAccessWithContext(arg0 context.Context, arg1 *ec2.DisableSerialConsoleAccessInput, arg2 ...request.Option) (*ec2.DisableSerialConsoleAccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableSerialConsoleAccessWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableSerialConsoleAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableSnapshotBlockPublicAccess mocks base method.
func (m *MockEC2API) DisableSnapshotBlockPublicAccess(arg0 *ec2.DisableSnapshotBlockPublicAccessInput) (*ec2.DisableSnapshotBlockPublicAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccess", arg0)
	ret0, _ := ret[0].(*ec2.DisableSnapshotBlockPublicAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableSnapshotBlockPublicAccess indicates an expected call of DisableSnapshotBlockPublicAccess.
func (mr *MockEC2APIMockRecorder) DisableSnapshotBlockPublicAccess(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSnapshotBlockPublicAccess", reflect.TypeOf((*MockEC2API)(nil).DisableSnapshotBlockPublicAccess), arg0)
}

// DisableSnapshotBlockPublicAccessRequest mocks base method.
func (m *MockEC2API) DisableSnapshotBlockPublicAccessRequest(arg0 *ec2.DisableSnapshotBlockPublicAccessInput) (*request.Request, *ec2.DisableSnapshotBlockPublicAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableSnapshotBlockPublicAccessOutput)
	return ret0, ret1
}

// DisableSnapshotBlockPublicAccessRequest indicates an expected call of DisableSnapshotBlockPublicAccessRequest.
func (mr *MockEC2APIMockRecorder) DisableSnapshotBlockPublicAccessRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSnapshotBlockPublicAccessRequest", reflect.TypeOf((*MockEC2API)(nil).DisableSnapshotBlockPublicAccessRequest), arg0)
}

// DisableSnapshotBlockPublicAccessWithContext mocks base method.
func (m *MockEC2API) DisableSnapshotBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.DisableSnapshotBlockPublicAccessInput, arg2 ...request.Option) (*ec2.DisableSnapshotBlockPublicAccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccessWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableSnapshotBlockPublicAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableTransitGatewayRouteTablePropagation mocks base method.
func (m *MockEC2API) DisableTransitGatewayRouteTablePropagation(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagation", arg0)
	ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableTransitGatewayRouteTablePropagation indicates an expected call of DisableTransitGatewayRouteTablePropagation.
func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagation), arg0)
}

// DisableTransitGatewayRouteTablePropagationRequest mocks base method.
func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.DisableTransitGatewayRouteTablePropagationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
	return ret0, ret1
}

// DisableTransitGatewayRouteTablePropagationRequest indicates an expected call of DisableTransitGatewayRouteTablePropagationRequest.
func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationRequest), arg0)
}

// DisableTransitGatewayRouteTablePropagationWithContext mocks base method.
func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationWithContext(arg0 context.Context, arg1 *ec2.DisableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableVgwRoutePropagation mocks base method.
func (m *MockEC2API) DisableVgwRoutePropagation(arg0 *ec2.DisableVgwRoutePropagationInput) (*ec2.DisableVgwRoutePropagationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableVgwRoutePropagation", arg0)
	ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableVgwRoutePropagation indicates an expected call of DisableVgwRoutePropagation.
func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagation), arg0)
}

// DisableVgwRoutePropagationRequest mocks base method.
func (m *MockEC2API) DisableVgwRoutePropagationRequest(arg0 *ec2.DisableVgwRoutePropagationInput) (*request.Request, *ec2.DisableVgwRoutePropagationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableVgwRoutePropagationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableVgwRoutePropagationOutput)
	return ret0, ret1
}

// DisableVgwRoutePropagationRequest indicates an expected call of DisableVgwRoutePropagationRequest.
func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagationRequest), arg0)
}

// DisableVgwRoutePropagationWithContext mocks base method.
func (m *MockEC2API) DisableVgwRoutePropagationWithContext(arg0 context.Context, arg1 *ec2.DisableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.DisableVgwRoutePropagationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableVgwRoutePropagationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableVpcClassicLink mocks base method.
func (m *MockEC2API) DisableVpcClassicLink(arg0 *ec2.DisableVpcClassicLinkInput) (*ec2.DisableVpcClassicLinkOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableVpcClassicLink", arg0)
	ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableVpcClassicLink indicates an expected call of DisableVpcClassicLink.
func (mr *MockEC2APIMockRecorder) DisableVpcClassicLink(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLink), arg0)
}

// DisableVpcClassicLinkDnsSupport mocks base method.
func (m *MockEC2API) DisableVpcClassicLinkDnsSupport(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupport", arg0)
	ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableVpcClassicLinkDnsSupport indicates an expected call of DisableVpcClassicLinkDnsSupport.
func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupport), arg0)
}

// DisableVpcClassicLinkDnsSupportRequest mocks base method.
func (m *MockEC2API) DisableVpcClassicLinkDnsSupportRequest(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DisableVpcClassicLinkDnsSupportOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkDnsSupportOutput)
	return ret0, ret1
}

// DisableVpcClassicLinkDnsSupportRequest indicates an expected call of DisableVpcClassicLinkDnsSupportRequest.
func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportRequest), arg0)
}

// DisableVpcClassicLinkDnsSupportWithContext mocks base method.
func (m *MockEC2API) DisableVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.DisableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableVpcClassicLinkRequest mocks base method.
func (m *MockEC2API) DisableVpcClassicLinkRequest(arg0 *ec2.DisableVpcClassicLinkInput) (*request.Request, *ec2.DisableVpcClassicLinkOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableVpcClassicLinkRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkOutput)
	return ret0, ret1
}

// DisableVpcClassicLinkRequest indicates an expected call of DisableVpcClassicLinkRequest.
func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkRequest), arg0)
}

// DisableVpcClassicLinkWithContext mocks base method.
func (m *MockEC2API) DisableVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.DisableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableVpcClassicLinkWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateAddress mocks base method.
func (m *MockEC2API) DisassociateAddress(arg0 *ec2.DisassociateAddressInput) (*ec2.DisassociateAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateAddress", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateAddress indicates an expected call of DisassociateAddress.
func (mr *MockEC2APIMockRecorder) DisassociateAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddress), arg0)
}

// DisassociateAddressRequest mocks base method.
func (m *MockEC2API) DisassociateAddressRequest(arg0 *ec2.DisassociateAddressInput) (*request.Request, *ec2.DisassociateAddressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateAddressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateAddressOutput)
	return ret0, ret1
}

// DisassociateAddressRequest indicates an expected call of DisassociateAddressRequest.
func (mr *MockEC2APIMockRecorder) DisassociateAddressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddressRequest), arg0)
}

// DisassociateAddressWithContext mocks base method.
func (m *MockEC2API) DisassociateAddressWithContext(arg0 context.Context, arg1 *ec2.DisassociateAddressInput, arg2 ...request.Option) (*ec2.DisassociateAddressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateAddressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateClientVpnTargetNetwork mocks base method.
func (m *MockEC2API) DisassociateClientVpnTargetNetwork(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetwork", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateClientVpnTargetNetwork indicates an expected call of DisassociateClientVpnTargetNetwork.
func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetwork), arg0)
}

// DisassociateClientVpnTargetNetworkRequest mocks base method.
func (m *MockEC2API) DisassociateClientVpnTargetNetworkRequest(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*request.Request, *ec2.DisassociateClientVpnTargetNetworkOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateClientVpnTargetNetworkOutput)
	return ret0, ret1
}

// DisassociateClientVpnTargetNetworkRequest indicates an expected call of DisassociateClientVpnTargetNetworkRequest.
func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkRequest), arg0)
}

// DisassociateClientVpnTargetNetworkWithContext mocks base method.
func (m *MockEC2API) DisassociateClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.DisassociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateEnclaveCertificateIamRole mocks base method.
func (m *MockEC2API) DisassociateEnclaveCertificateIamRole(arg0 *ec2.DisassociateEnclaveCertificateIamRoleInput) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRole", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateEnclaveCertificateIamRole indicates an expected call of DisassociateEnclaveCertificateIamRole.
func (mr *MockEC2APIMockRecorder) DisassociateEnclaveCertificateIamRole(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateEnclaveCertificateIamRole", reflect.TypeOf((*MockEC2API)(nil).DisassociateEnclaveCertificateIamRole), arg0)
}

// DisassociateEnclaveCertificateIamRoleRequest mocks base method.
func (m *MockEC2API) DisassociateEnclaveCertificateIamRoleRequest(arg0 *ec2.DisassociateEnclaveCertificateIamRoleInput) (*request.Request, *ec2.DisassociateEnclaveCertificateIamRoleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRoleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
	return ret0, ret1
}

// DisassociateEnclaveCertificateIamRoleRequest indicates an expected call of DisassociateEnclaveCertificateIamRoleRequest.
func (mr *MockEC2APIMockRecorder) DisassociateEnclaveCertificateIamRoleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateEnclaveCertificateIamRoleRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateEnclaveCertificateIamRoleRequest), arg0)
}

// DisassociateEnclaveCertificateIamRoleWithContext mocks base method.
func (m *MockEC2API) DisassociateEnclaveCertificateIamRoleWithContext(arg0 context.Context, arg1 *ec2.DisassociateEnclaveCertificateIamRoleInput, arg2 ...request.Option) (*ec2.DisassociateEnclaveCertificateIamRoleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateEnclaveCertificateIamRoleWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateEnclaveCertificateIamRoleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateIamInstanceProfile mocks base method.
func (m *MockEC2API) DisassociateIamInstanceProfile(arg0 *ec2.DisassociateIamInstanceProfileInput) (*ec2.DisassociateIamInstanceProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateIamInstanceProfile", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateIamInstanceProfile indicates an expected call of DisassociateIamInstanceProfile.
func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfile(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfile), arg0)
}

// DisassociateIamInstanceProfileRequest mocks base method.
func (m *MockEC2API) DisassociateIamInstanceProfileRequest(arg0 *ec2.DisassociateIamInstanceProfileInput) (*request.Request, *ec2.DisassociateIamInstanceProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateIamInstanceProfileOutput)
	return ret0, ret1
}

// DisassociateIamInstanceProfileRequest indicates an expected call of DisassociateIamInstanceProfileRequest.
func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfileRequest), arg0)
}

// DisassociateIamInstanceProfileWithContext mocks base method.
func (m *MockEC2API) DisassociateIamInstanceProfileWithContext(arg0 context.Context, arg1 *ec2.DisassociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.DisassociateIamInstanceProfileOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateInstanceEventWindow mocks base method.
func (m *MockEC2API) DisassociateInstanceEventWindow(arg0 *ec2.DisassociateInstanceEventWindowInput) (*ec2.DisassociateInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateInstanceEventWindow", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateInstanceEventWindow indicates an expected call of DisassociateInstanceEventWindow.
func (mr *MockEC2APIMockRecorder) DisassociateInstanceEventWindow(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).DisassociateInstanceEventWindow), arg0)
}

// DisassociateInstanceEventWindowRequest mocks base method.
func (m *MockEC2API) DisassociateInstanceEventWindowRequest(arg0 *ec2.DisassociateInstanceEventWindowInput) (*request.Request, *ec2.DisassociateInstanceEventWindowOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateInstanceEventWindowRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateInstanceEventWindowOutput)
	return ret0, ret1
}

// DisassociateInstanceEventWindowRequest indicates an expected call of DisassociateInstanceEventWindowRequest.
func (mr *MockEC2APIMockRecorder) DisassociateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateInstanceEventWindowRequest), arg0)
}

// DisassociateInstanceEventWindowWithContext mocks base method.
func (m *MockEC2API) DisassociateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.DisassociateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.DisassociateInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateInstanceEventWindowWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateIpamByoasn mocks base method.
func (m *MockEC2API) DisassociateIpamByoasn(arg0 *ec2.DisassociateIpamByoasnInput) (*ec2.DisassociateIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateIpamByoasn", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateIpamByoasn indicates an expected call of DisassociateIpamByoasn.
func (mr *MockEC2APIMockRecorder) DisassociateIpamByoasn(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamByoasn), arg0)
}

// DisassociateIpamByoasnRequest mocks base method.
func (m *MockEC2API) DisassociateIpamByoasnRequest(arg0 *ec2.DisassociateIpamByoasnInput) (*request.Request, *ec2.DisassociateIpamByoasnOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateIpamByoasnRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateIpamByoasnOutput)
	return ret0, ret1
}

// DisassociateIpamByoasnRequest indicates an expected call of DisassociateIpamByoasnRequest.
func (mr *MockEC2APIMockRecorder) DisassociateIpamByoasnRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamByoasnRequest), arg0)
}

// DisassociateIpamByoasnWithContext mocks base method.
func (m *MockEC2API) DisassociateIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DisassociateIpamByoasnInput, arg2 ...request.Option) (*ec2.DisassociateIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateIpamByoasnWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateIpamResourceDiscovery mocks base method.
func (m *MockEC2API) DisassociateIpamResourceDiscovery(arg0 *ec2.DisassociateIpamResourceDiscoveryInput) (*ec2.DisassociateIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscovery", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateIpamResourceDiscovery indicates an expected call of DisassociateIpamResourceDiscovery.
func (mr *MockEC2APIMockRecorder) DisassociateIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamResourceDiscovery), arg0)
}

// DisassociateIpamResourceDiscoveryRequest mocks base method.
func (m *MockEC2API) DisassociateIpamResourceDiscoveryRequest(arg0 *ec2.DisassociateIpamResourceDiscoveryInput) (*request.Request, *ec2.DisassociateIpamResourceDiscoveryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscoveryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateIpamResourceDiscoveryOutput)
	return ret0, ret1
}

// DisassociateIpamResourceDiscoveryRequest indicates an expected call of DisassociateIpamResourceDiscoveryRequest.
func (mr *MockEC2APIMockRecorder) DisassociateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIpamResourceDiscoveryRequest), arg0)
}

// DisassociateIpamResourceDiscoveryWithContext mocks base method.
func (m *MockEC2API) DisassociateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.DisassociateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.DisassociateIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscoveryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateNatGatewayAddress mocks base method.
func (m *MockEC2API) DisassociateNatGatewayAddress(arg0 *ec2.DisassociateNatGatewayAddressInput) (*ec2.DisassociateNatGatewayAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateNatGatewayAddress", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateNatGatewayAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateNatGatewayAddress indicates an expected call of DisassociateNatGatewayAddress.
func (mr *MockEC2APIMockRecorder) DisassociateNatGatewayAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateNatGatewayAddress), arg0)
}

// DisassociateNatGatewayAddressRequest mocks base method.
func (m *MockEC2API) DisassociateNatGatewayAddressRequest(arg0 *ec2.DisassociateNatGatewayAddressInput) (*request.Request, *ec2.DisassociateNatGatewayAddressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateNatGatewayAddressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateNatGatewayAddressOutput)
	return ret0, ret1
}

// DisassociateNatGatewayAddressRequest indicates an expected call of DisassociateNatGatewayAddressRequest.
func (mr *MockEC2APIMockRecorder) DisassociateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateNatGatewayAddressRequest), arg0)
}

// DisassociateNatGatewayAddressWithContext mocks base method.
func (m *MockEC2API) DisassociateNatGatewayAddressWithContext(arg0 context.Context, arg1 *ec2.DisassociateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.DisassociateNatGatewayAddressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateNatGatewayAddressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateNatGatewayAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateRouteTable mocks base method.
func (m *MockEC2API) DisassociateRouteTable(arg0 *ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateRouteTable indicates an expected call of DisassociateRouteTable.
func (mr *MockEC2APIMockRecorder) DisassociateRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTable), arg0)
}

// DisassociateRouteTableRequest mocks base method.
func (m *MockEC2API) DisassociateRouteTableRequest(arg0 *ec2.DisassociateRouteTableInput) (*request.Request, *ec2.DisassociateRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateRouteTableOutput)
	return ret0, ret1
}

// DisassociateRouteTableRequest indicates an expected call of DisassociateRouteTableRequest.
func (mr *MockEC2APIMockRecorder) DisassociateRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTableRequest), arg0)
}

// DisassociateRouteTableWithContext mocks base method.
func (m *MockEC2API) DisassociateRouteTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateSubnetCidrBlock mocks base method.
func (m *MockEC2API) DisassociateSubnetCidrBlock(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*ec2.DisassociateSubnetCidrBlockOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlock", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateSubnetCidrBlock indicates an expected call of DisassociateSubnetCidrBlock.
func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlock), arg0)
}

// DisassociateSubnetCidrBlockRequest mocks base method.
func (m *MockEC2API) DisassociateSubnetCidrBlockRequest(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*request.Request, *ec2.DisassociateSubnetCidrBlockOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateSubnetCidrBlockOutput)
	return ret0, ret1
}

// DisassociateSubnetCidrBlockRequest indicates an expected call of DisassociateSubnetCidrBlockRequest.
func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlockRequest), arg0)
}

// DisassociateSubnetCidrBlockWithContext mocks base method.
func (m *MockEC2API) DisassociateSubnetCidrBlockWithContext(arg0 context.Context, arg1 *ec2.DisassociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateSubnetCidrBlockOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateTransitGatewayMulticastDomain mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayMulticastDomain(arg0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomain", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateTransitGatewayMulticastDomain indicates an expected call of DisassociateTransitGatewayMulticastDomain.
func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomain), arg0)
}

// DisassociateTransitGatewayMulticastDomainRequest mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayMulticastDomainRequest(arg0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DisassociateTransitGatewayMulticastDomainOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomainRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
	return ret0, ret1
}

// DisassociateTransitGatewayMulticastDomainRequest indicates an expected call of DisassociateTransitGatewayMulticastDomainRequest.
func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomainRequest), arg0)
}

// DisassociateTransitGatewayMulticastDomainWithContext mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomainWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayMulticastDomainOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateTransitGatewayPolicyTable mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayPolicyTable(arg0 *ec2.DisassociateTransitGatewayPolicyTableInput) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTable", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayPolicyTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateTransitGatewayPolicyTable indicates an expected call of DisassociateTransitGatewayPolicyTable.
func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayPolicyTable), arg0)
}

// DisassociateTransitGatewayPolicyTableRequest mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayPolicyTableRequest(arg0 *ec2.DisassociateTransitGatewayPolicyTableInput) (*request.Request, *ec2.DisassociateTransitGatewayPolicyTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayPolicyTableOutput)
	return ret0, ret1
}

// DisassociateTransitGatewayPolicyTableRequest indicates an expected call of DisassociateTransitGatewayPolicyTableRequest.
func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayPolicyTableRequest), arg0)
}

// DisassociateTransitGatewayPolicyTableWithContext mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayPolicyTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateTransitGatewayRouteTable mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayRouteTable(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTable", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateTransitGatewayRouteTable indicates an expected call of DisassociateTransitGatewayRouteTable.
func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTable), arg0)
}

// DisassociateTransitGatewayRouteTableRequest mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayRouteTableRequest(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*request.Request, *ec2.DisassociateTransitGatewayRouteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayRouteTableOutput)
	return ret0, ret1
}

// DisassociateTransitGatewayRouteTableRequest indicates an expected call of DisassociateTransitGatewayRouteTableRequest.
func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableRequest), arg0)
}

// DisassociateTransitGatewayRouteTableWithContext mocks base method.
func (m *MockEC2API) DisassociateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateTrunkInterface mocks base method.
func (m *MockEC2API) DisassociateTrunkInterface(arg0 *ec2.DisassociateTrunkInterfaceInput) (*ec2.DisassociateTrunkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTrunkInterface", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateTrunkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateTrunkInterface indicates an expected call of DisassociateTrunkInterface.
func (mr *MockEC2APIMockRecorder) DisassociateTrunkInterface(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterface", reflect.TypeOf((*MockEC2API)(nil).DisassociateTrunkInterface), arg0)
}

// DisassociateTrunkInterfaceRequest mocks base method.
func (m *MockEC2API) DisassociateTrunkInterfaceRequest(arg0 *ec2.DisassociateTrunkInterfaceInput) (*request.Request, *ec2.DisassociateTrunkInterfaceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateTrunkInterfaceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateTrunkInterfaceOutput)
	return ret0, ret1
}

// DisassociateTrunkInterfaceRequest indicates an expected call of DisassociateTrunkInterfaceRequest.
func (mr *MockEC2APIMockRecorder) DisassociateTrunkInterfaceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTrunkInterfaceRequest), arg0)
}

// DisassociateTrunkInterfaceWithContext mocks base method.
func (m *MockEC2API) DisassociateTrunkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DisassociateTrunkInterfaceInput, arg2 ...request.Option) (*ec2.DisassociateTrunkInterfaceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateTrunkInterfaceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateTrunkInterfaceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateVpcCidrBlock mocks base method.
func (m *MockEC2API) DisassociateVpcCidrBlock(arg0 *ec2.DisassociateVpcCidrBlockInput) (*ec2.DisassociateVpcCidrBlockOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateVpcCidrBlock", arg0)
	ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisassociateVpcCidrBlock indicates an expected call of DisassociateVpcCidrBlock.
func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlock), arg0)
}

// DisassociateVpcCidrBlockRequest mocks base method.
func (m *MockEC2API) DisassociateVpcCidrBlockRequest(arg0 *ec2.DisassociateVpcCidrBlockInput) (*request.Request, *ec2.DisassociateVpcCidrBlockOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.DisassociateVpcCidrBlockOutput)
	return ret0, ret1
}

// DisassociateVpcCidrBlockRequest indicates an expected call of DisassociateVpcCidrBlockRequest.
func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockRequest), arg0)
}

// DisassociateVpcCidrBlockWithContext mocks base method.
func (m *MockEC2API) DisassociateVpcCidrBlockWithContext(arg0 context.Context, arg1 *ec2.DisassociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateVpcCidrBlockOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableAddressTransfer mocks base method.
func (m *MockEC2API) EnableAddressTransfer(arg0 *ec2.EnableAddressTransferInput) (*ec2.EnableAddressTransferOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAddressTransfer", arg0)
	ret0, _ := ret[0].(*ec2.EnableAddressTransferOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableAddressTransfer indicates an expected call of EnableAddressTransfer.
func (mr *MockEC2APIMockRecorder) EnableAddressTransfer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAddressTransfer", reflect.TypeOf((*MockEC2API)(nil).EnableAddressTransfer), arg0)
}

// EnableAddressTransferRequest mocks base method.
func (m *MockEC2API) EnableAddressTransferRequest(arg0 *ec2.EnableAddressTransferInput) (*request.Request, *ec2.EnableAddressTransferOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAddressTransferRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableAddressTransferOutput)
	return ret0, ret1
}

// EnableAddressTransferRequest indicates an expected call of EnableAddressTransferRequest.
func (mr *MockEC2APIMockRecorder) EnableAddressTransferRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAddressTransferRequest", reflect.TypeOf((*MockEC2API)(nil).EnableAddressTransferRequest), arg0)
}

// EnableAddressTransferWithContext mocks base method.
func (m *MockEC2API) EnableAddressTransferWithContext(arg0 context.Context, arg1 *ec2.EnableAddressTransferInput, arg2 ...request.Option) (*ec2.EnableAddressTransferOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableAddressTransferWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableAddressTransferOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableAwsNetworkPerformanceMetricSubscription mocks base method.
func (m *MockEC2API) EnableAwsNetworkPerformanceMetricSubscription(arg0 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscription", arg0)
	ret0, _ := ret[0].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableAwsNetworkPerformanceMetricSubscription indicates an expected call of EnableAwsNetworkPerformanceMetricSubscription.
func (mr *MockEC2APIMockRecorder) EnableAwsNetworkPerformanceMetricSubscription(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAwsNetworkPerformanceMetricSubscription", reflect.TypeOf((*MockEC2API)(nil).EnableAwsNetworkPerformanceMetricSubscription), arg0)
}

// EnableAwsNetworkPerformanceMetricSubscriptionRequest mocks base method.
func (m *MockEC2API) EnableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput) (*request.Request, *ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput)
	return ret0, ret1
}

// EnableAwsNetworkPerformanceMetricSubscriptionRequest indicates an expected call of EnableAwsNetworkPerformanceMetricSubscriptionRequest.
func (mr *MockEC2APIMockRecorder) EnableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAwsNetworkPerformanceMetricSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).EnableAwsNetworkPerformanceMetricSubscriptionRequest), arg0)
}

// EnableAwsNetworkPerformanceMetricSubscriptionWithContext mocks base method.
func (m *MockEC2API) EnableAwsNetworkPerformanceMetricSubscriptionWithContext(arg0 context.Context, arg1 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, arg2 ...request.Option) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableEbsEncryptionByDefault mocks base method.
func (m *MockEC2API) EnableEbsEncryptionByDefault(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*ec2.EnableEbsEncryptionByDefaultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefault", arg0)
	ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableEbsEncryptionByDefault indicates an expected call of EnableEbsEncryptionByDefault.
func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefault), arg0)
}

// EnableEbsEncryptionByDefaultRequest mocks base method.
func (m *MockEC2API) EnableEbsEncryptionByDefaultRequest(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*request.Request, *ec2.EnableEbsEncryptionByDefaultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableEbsEncryptionByDefaultOutput)
	return ret0, ret1
}

// EnableEbsEncryptionByDefaultRequest indicates an expected call of EnableEbsEncryptionByDefaultRequest.
func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultRequest), arg0)
}

// EnableEbsEncryptionByDefaultWithContext mocks base method.
func (m *MockEC2API) EnableEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.EnableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.EnableEbsEncryptionByDefaultOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableFastLaunch mocks base method.
func (m *MockEC2API) EnableFastLaunch(arg0 *ec2.EnableFastLaunchInput) (*ec2.EnableFastLaunchOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableFastLaunch", arg0)
	ret0, _ := ret[0].(*ec2.EnableFastLaunchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableFastLaunch indicates an expected call of EnableFastLaunch.
func (mr *MockEC2APIMockRecorder) EnableFastLaunch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastLaunch", reflect.TypeOf((*MockEC2API)(nil).EnableFastLaunch), arg0)
}

// EnableFastLaunchRequest mocks base method.
func (m *MockEC2API) EnableFastLaunchRequest(arg0 *ec2.EnableFastLaunchInput) (*request.Request, *ec2.EnableFastLaunchOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableFastLaunchRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableFastLaunchOutput)
	return ret0, ret1
}

// EnableFastLaunchRequest indicates an expected call of EnableFastLaunchRequest.
func (mr *MockEC2APIMockRecorder) EnableFastLaunchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastLaunchRequest", reflect.TypeOf((*MockEC2API)(nil).EnableFastLaunchRequest), arg0)
}

// EnableFastLaunchWithContext mocks base method.
func (m *MockEC2API) EnableFastLaunchWithContext(arg0 context.Context, arg1 *ec2.EnableFastLaunchInput, arg2 ...request.Option) (*ec2.EnableFastLaunchOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableFastLaunchWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableFastLaunchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableFastSnapshotRestores mocks base method.
func (m *MockEC2API) EnableFastSnapshotRestores(arg0 *ec2.EnableFastSnapshotRestoresInput) (*ec2.EnableFastSnapshotRestoresOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableFastSnapshotRestores", arg0)
	ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableFastSnapshotRestores indicates an expected call of EnableFastSnapshotRestores.
func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestores(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestores), arg0)
}

// EnableFastSnapshotRestoresRequest mocks base method.
func (m *MockEC2API) EnableFastSnapshotRestoresRequest(arg0 *ec2.EnableFastSnapshotRestoresInput) (*request.Request, *ec2.EnableFastSnapshotRestoresOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableFastSnapshotRestoresOutput)
	return ret0, ret1
}

// EnableFastSnapshotRestoresRequest indicates an expected call of EnableFastSnapshotRestoresRequest.
func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresRequest), arg0)
}

// EnableFastSnapshotRestoresWithContext mocks base method.
func (m *MockEC2API) EnableFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.EnableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.EnableFastSnapshotRestoresOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableImage mocks base method.
func (m *MockEC2API) EnableImage(arg0 *ec2.EnableImageInput) (*ec2.EnableImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableImage", arg0)
	ret0, _ := ret[0].(*ec2.EnableImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableImage indicates an expected call of EnableImage.
func (mr *MockEC2APIMockRecorder) EnableImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImage", reflect.TypeOf((*MockEC2API)(nil).EnableImage), arg0)
}

// EnableImageBlockPublicAccess mocks base method.
func (m *MockEC2API) EnableImageBlockPublicAccess(arg0 *ec2.EnableImageBlockPublicAccessInput) (*ec2.EnableImageBlockPublicAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableImageBlockPublicAccess", arg0)
	ret0, _ := ret[0].(*ec2.EnableImageBlockPublicAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableImageBlockPublicAccess indicates an expected call of EnableImageBlockPublicAccess.
func (mr *MockEC2APIMockRecorder) EnableImageBlockPublicAccess(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageBlockPublicAccess", reflect.TypeOf((*MockEC2API)(nil).EnableImageBlockPublicAccess), arg0)
}

// EnableImageBlockPublicAccessRequest mocks base method.
func (m *MockEC2API) EnableImageBlockPublicAccessRequest(arg0 *ec2.EnableImageBlockPublicAccessInput) (*request.Request, *ec2.EnableImageBlockPublicAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableImageBlockPublicAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableImageBlockPublicAccessOutput)
	return ret0, ret1
}

// EnableImageBlockPublicAccessRequest indicates an expected call of EnableImageBlockPublicAccessRequest.
func (mr *MockEC2APIMockRecorder) EnableImageBlockPublicAccessRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageBlockPublicAccessRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageBlockPublicAccessRequest), arg0)
}

// EnableImageBlockPublicAccessWithContext mocks base method.
func (m *MockEC2API) EnableImageBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.EnableImageBlockPublicAccessInput, arg2 ...request.Option) (*ec2.EnableImageBlockPublicAccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableImageBlockPublicAccessWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableImageBlockPublicAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableImageDeprecation mocks base method.
func (m *MockEC2API) EnableImageDeprecation(arg0 *ec2.EnableImageDeprecationInput) (*ec2.EnableImageDeprecationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableImageDeprecation", arg0)
	ret0, _ := ret[0].(*ec2.EnableImageDeprecationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableImageDeprecation indicates an expected call of EnableImageDeprecation.
func (mr *MockEC2APIMockRecorder) EnableImageDeprecation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecation", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecation), arg0)
}

// EnableImageDeprecationRequest mocks base method.
func (m *MockEC2API) EnableImageDeprecationRequest(arg0 *ec2.EnableImageDeprecationInput) (*request.Request, *ec2.EnableImageDeprecationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableImageDeprecationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableImageDeprecationOutput)
	return ret0, ret1
}

// EnableImageDeprecationRequest indicates an expected call of EnableImageDeprecationRequest.
func (mr *MockEC2APIMockRecorder) EnableImageDeprecationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeprecationRequest), arg0)
}

// EnableImageDeprecationWithContext mocks base method.
func (m *MockEC2API) EnableImageDeprecationWithContext(arg0 context.Context, arg1 *ec2.EnableImageDeprecationInput, arg2 ...request.Option) (*ec2.EnableImageDeprecationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableImageDeprecationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableImageDeprecationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableImageDeregistrationProtection mocks base method.
func (m *MockEC2API) EnableImageDeregistrationProtection(arg0 *ec2.EnableImageDeregistrationProtectionInput) (*ec2.EnableImageDeregistrationProtectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableImageDeregistrationProtection", arg0)
	ret0, _ := ret[0].(*ec2.EnableImageDeregistrationProtectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableImageDeregistrationProtection indicates an expected call of EnableImageDeregistrationProtection.
func (mr *MockEC2APIMockRecorder) EnableImageDeregistrationProtection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeregistrationProtection", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeregistrationProtection), arg0)
}

// EnableImageDeregistrationProtectionRequest mocks base method.
func (m *MockEC2API) EnableImageDeregistrationProtectionRequest(arg0 *ec2.EnableImageDeregistrationProtectionInput) (*request.Request, *ec2.EnableImageDeregistrationProtectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableImageDeregistrationProtectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableImageDeregistrationProtectionOutput)
	return ret0, ret1
}

// EnableImageDeregistrationProtectionRequest indicates an expected call of EnableImageDeregistrationProtectionRequest.
func (mr *MockEC2APIMockRecorder) EnableImageDeregistrationProtectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeregistrationProtectionRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageDeregistrationProtectionRequest), arg0)
}

// EnableImageDeregistrationProtectionWithContext mocks base method.
func (m *MockEC2API) EnableImageDeregistrationProtectionWithContext(arg0 context.Context, arg1 *ec2.EnableImageDeregistrationProtectionInput, arg2 ...request.Option) (*ec2.EnableImageDeregistrationProtectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableImageDeregistrationProtectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableImageDeregistrationProtectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableImageRequest mocks base method.
func (m *MockEC2API) EnableImageRequest(arg0 *ec2.EnableImageInput) (*request.Request, *ec2.EnableImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableImageOutput)
	return ret0, ret1
}

// EnableImageRequest indicates an expected call of EnableImageRequest.
func (mr *MockEC2APIMockRecorder) EnableImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageRequest", reflect.TypeOf((*MockEC2API)(nil).EnableImageRequest), arg0)
}

// EnableImageWithContext mocks base method.
func (m *MockEC2API) EnableImageWithContext(arg0 context.Context, arg1 *ec2.EnableImageInput, arg2 ...request.Option) (*ec2.EnableImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableIpamOrganizationAdminAccount mocks base method.
func (m *MockEC2API) EnableIpamOrganizationAdminAccount(arg0 *ec2.EnableIpamOrganizationAdminAccountInput) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccount", arg0)
	ret0, _ := ret[0].(*ec2.EnableIpamOrganizationAdminAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableIpamOrganizationAdminAccount indicates an expected call of EnableIpamOrganizationAdminAccount.
func (mr *MockEC2APIMockRecorder) EnableIpamOrganizationAdminAccount(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableIpamOrganizationAdminAccount", reflect.TypeOf((*MockEC2API)(nil).EnableIpamOrganizationAdminAccount), arg0)
}

// EnableIpamOrganizationAdminAccountRequest mocks base method.
func (m *MockEC2API) EnableIpamOrganizationAdminAccountRequest(arg0 *ec2.EnableIpamOrganizationAdminAccountInput) (*request.Request, *ec2.EnableIpamOrganizationAdminAccountOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccountRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableIpamOrganizationAdminAccountOutput)
	return ret0, ret1
}

// EnableIpamOrganizationAdminAccountRequest indicates an expected call of EnableIpamOrganizationAdminAccountRequest.
func (mr *MockEC2APIMockRecorder) EnableIpamOrganizationAdminAccountRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableIpamOrganizationAdminAccountRequest", reflect.TypeOf((*MockEC2API)(nil).EnableIpamOrganizationAdminAccountRequest), arg0)
}

// EnableIpamOrganizationAdminAccountWithContext mocks base method.
func (m *MockEC2API) EnableIpamOrganizationAdminAccountWithContext(arg0 context.Context, arg1 *ec2.EnableIpamOrganizationAdminAccountInput, arg2 ...request.Option) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccountWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableIpamOrganizationAdminAccountOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableReachabilityAnalyzerOrganizationSharing mocks base method.
func (m *MockEC2API) EnableReachabilityAnalyzerOrganizationSharing(arg0 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharing", arg0)
	ret0, _ := ret[0].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableReachabilityAnalyzerOrganizationSharing indicates an expected call of EnableReachabilityAnalyzerOrganizationSharing.
func (mr *MockEC2APIMockRecorder) EnableReachabilityAnalyzerOrganizationSharing(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableReachabilityAnalyzerOrganizationSharing", reflect.TypeOf((*MockEC2API)(nil).EnableReachabilityAnalyzerOrganizationSharing), arg0)
}

// EnableReachabilityAnalyzerOrganizationSharingRequest mocks base method.
func (m *MockEC2API) EnableReachabilityAnalyzerOrganizationSharingRequest(arg0 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput) (*request.Request, *ec2.EnableReachabilityAnalyzerOrganizationSharingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput)
	return ret0, ret1
}

// EnableReachabilityAnalyzerOrganizationSharingRequest indicates an expected call of EnableReachabilityAnalyzerOrganizationSharingRequest.
func (mr *MockEC2APIMockRecorder) EnableReachabilityAnalyzerOrganizationSharingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableReachabilityAnalyzerOrganizationSharingRequest", reflect.TypeOf((*MockEC2API)(nil).EnableReachabilityAnalyzerOrganizationSharingRequest), arg0)
}

// EnableReachabilityAnalyzerOrganizationSharingWithContext mocks base method.
func (m *MockEC2API) EnableReachabilityAnalyzerOrganizationSharingWithContext(arg0 context.Context, arg1 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, arg2 ...request.Option) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharingWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableSerialConsoleAccess mocks base method.
func (m *MockEC2API) EnableSerialConsoleAccess(arg0 *ec2.EnableSerialConsoleAccessInput) (*ec2.EnableSerialConsoleAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSerialConsoleAccess", arg0)
	ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableSerialConsoleAccess indicates an expected call of EnableSerialConsoleAccess.
func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccess(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccess", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccess), arg0)
}

// EnableSerialConsoleAccessRequest mocks base method.
func (m *MockEC2API) EnableSerialConsoleAccessRequest(arg0 *ec2.EnableSerialConsoleAccessInput) (*request.Request, *ec2.EnableSerialConsoleAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSerialConsoleAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableSerialConsoleAccessOutput)
	return ret0, ret1
}

// EnableSerialConsoleAccessRequest indicates an expected call of EnableSerialConsoleAccessRequest.
func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccessRequest), arg0)
}

// EnableSerialConsoleAccessWithContext mocks base method.
func (m *MockEC2API) EnableSerialConsoleAccessWithContext(arg0 context.Context, arg1 *ec2.EnableSerialConsoleAccessInput, arg2 ...request.Option) (*ec2.EnableSerialConsoleAccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableSerialConsoleAccessWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableSnapshotBlockPublicAccess mocks base method.
func (m *MockEC2API) EnableSnapshotBlockPublicAccess(arg0 *ec2.EnableSnapshotBlockPublicAccessInput) (*ec2.EnableSnapshotBlockPublicAccessOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccess", arg0)
	ret0, _ := ret[0].(*ec2.EnableSnapshotBlockPublicAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableSnapshotBlockPublicAccess indicates an expected call of EnableSnapshotBlockPublicAccess.
func (mr *MockEC2APIMockRecorder) EnableSnapshotBlockPublicAccess(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSnapshotBlockPublicAccess", reflect.TypeOf((*MockEC2API)(nil).EnableSnapshotBlockPublicAccess), arg0)
}

// EnableSnapshotBlockPublicAccessRequest mocks base method.
func (m *MockEC2API) EnableSnapshotBlockPublicAccessRequest(arg0 *ec2.EnableSnapshotBlockPublicAccessInput) (*request.Request, *ec2.EnableSnapshotBlockPublicAccessOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccessRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableSnapshotBlockPublicAccessOutput)
	return ret0, ret1
}

// EnableSnapshotBlockPublicAccessRequest indicates an expected call of EnableSnapshotBlockPublicAccessRequest.
func (mr *MockEC2APIMockRecorder) EnableSnapshotBlockPublicAccessRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSnapshotBlockPublicAccessRequest", reflect.TypeOf((*MockEC2API)(nil).EnableSnapshotBlockPublicAccessRequest), arg0)
}

// EnableSnapshotBlockPublicAccessWithContext mocks base method.
func (m *MockEC2API) EnableSnapshotBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.EnableSnapshotBlockPublicAccessInput, arg2 ...request.Option) (*ec2.EnableSnapshotBlockPublicAccessOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccessWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableSnapshotBlockPublicAccessOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableTransitGatewayRouteTablePropagation mocks base method.
func (m *MockEC2API) EnableTransitGatewayRouteTablePropagation(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagation", arg0)
	ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableTransitGatewayRouteTablePropagation indicates an expected call of EnableTransitGatewayRouteTablePropagation.
func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagation), arg0)
}

// EnableTransitGatewayRouteTablePropagationRequest mocks base method.
func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.EnableTransitGatewayRouteTablePropagationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
	return ret0, ret1
}

// EnableTransitGatewayRouteTablePropagationRequest indicates an expected call of EnableTransitGatewayRouteTablePropagationRequest.
func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationRequest), arg0)
}

// EnableTransitGatewayRouteTablePropagationWithContext mocks base method.
func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationWithContext(arg0 context.Context, arg1 *ec2.EnableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableVgwRoutePropagation mocks base method.
func (m *MockEC2API) EnableVgwRoutePropagation(arg0 *ec2.EnableVgwRoutePropagationInput) (*ec2.EnableVgwRoutePropagationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVgwRoutePropagation", arg0)
	ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableVgwRoutePropagation indicates an expected call of EnableVgwRoutePropagation.
func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagation), arg0)
}

// EnableVgwRoutePropagationRequest mocks base method.
func (m *MockEC2API) EnableVgwRoutePropagationRequest(arg0 *ec2.EnableVgwRoutePropagationInput) (*request.Request, *ec2.EnableVgwRoutePropagationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVgwRoutePropagationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableVgwRoutePropagationOutput)
	return ret0, ret1
}

// EnableVgwRoutePropagationRequest indicates an expected call of EnableVgwRoutePropagationRequest.
func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagationRequest), arg0)
}

// EnableVgwRoutePropagationWithContext mocks base method.
func (m *MockEC2API) EnableVgwRoutePropagationWithContext(arg0 context.Context, arg1 *ec2.EnableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.EnableVgwRoutePropagationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableVgwRoutePropagationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableVolumeIO mocks base method.
func (m *MockEC2API) EnableVolumeIO(arg0 *ec2.EnableVolumeIOInput) (*ec2.EnableVolumeIOOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVolumeIO", arg0)
	ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableVolumeIO indicates an expected call of EnableVolumeIO.
func (mr *MockEC2APIMockRecorder) EnableVolumeIO(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIO", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIO), arg0)
}

// EnableVolumeIORequest mocks base method.
func (m *MockEC2API) EnableVolumeIORequest(arg0 *ec2.EnableVolumeIOInput) (*request.Request, *ec2.EnableVolumeIOOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVolumeIORequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableVolumeIOOutput)
	return ret0, ret1
}

// EnableVolumeIORequest indicates an expected call of EnableVolumeIORequest.
func (mr *MockEC2APIMockRecorder) EnableVolumeIORequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIORequest", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIORequest), arg0)
}

// EnableVolumeIOWithContext mocks base method.
func (m *MockEC2API) EnableVolumeIOWithContext(arg0 context.Context, arg1 *ec2.EnableVolumeIOInput, arg2 ...request.Option) (*ec2.EnableVolumeIOOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableVolumeIOWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableVpcClassicLink mocks base method.
func (m *MockEC2API) EnableVpcClassicLink(arg0 *ec2.EnableVpcClassicLinkInput) (*ec2.EnableVpcClassicLinkOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVpcClassicLink", arg0)
	ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableVpcClassicLink indicates an expected call of EnableVpcClassicLink.
func (mr *MockEC2APIMockRecorder) EnableVpcClassicLink(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLink), arg0)
}

// EnableVpcClassicLinkDnsSupport mocks base method.
func (m *MockEC2API) EnableVpcClassicLinkDnsSupport(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupport", arg0)
	ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableVpcClassicLinkDnsSupport indicates an expected call of EnableVpcClassicLinkDnsSupport.
func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupport), arg0)
}

// EnableVpcClassicLinkDnsSupportRequest mocks base method.
func (m *MockEC2API) EnableVpcClassicLinkDnsSupportRequest(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.EnableVpcClassicLinkDnsSupportOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkDnsSupportOutput)
	return ret0, ret1
}

// EnableVpcClassicLinkDnsSupportRequest indicates an expected call of EnableVpcClassicLinkDnsSupportRequest.
func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportRequest), arg0)
}

// EnableVpcClassicLinkDnsSupportWithContext mocks base method.
func (m *MockEC2API) EnableVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.EnableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnableVpcClassicLinkRequest mocks base method.
func (m *MockEC2API) EnableVpcClassicLinkRequest(arg0 *ec2.EnableVpcClassicLinkInput) (*request.Request, *ec2.EnableVpcClassicLinkOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVpcClassicLinkRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkOutput)
	return ret0, ret1
}

// EnableVpcClassicLinkRequest indicates an expected call of EnableVpcClassicLinkRequest.
func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkRequest), arg0)
}

// EnableVpcClassicLinkWithContext mocks base method.
func (m *MockEC2API) EnableVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.EnableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableVpcClassicLinkWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportClientVpnClientCertificateRevocationList mocks base method.
func (m *MockEC2API) ExportClientVpnClientCertificateRevocationList(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationList", arg0)
	ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportClientVpnClientCertificateRevocationList indicates an expected call of ExportClientVpnClientCertificateRevocationList.
func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationList), arg0)
}

// ExportClientVpnClientCertificateRevocationListRequest mocks base method.
func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ExportClientVpnClientCertificateRevocationListOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
	return ret0, ret1
}

// ExportClientVpnClientCertificateRevocationListRequest indicates an expected call of ExportClientVpnClientCertificateRevocationListRequest.
func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListRequest), arg0)
}

// ExportClientVpnClientCertificateRevocationListWithContext mocks base method.
func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListWithContext(arg0 context.Context, arg1 *ec2.ExportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportClientVpnClientConfiguration mocks base method.
func (m *MockEC2API) ExportClientVpnClientConfiguration(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*ec2.ExportClientVpnClientConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportClientVpnClientConfiguration", arg0)
	ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportClientVpnClientConfiguration indicates an expected call of ExportClientVpnClientConfiguration.
func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfiguration", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfiguration), arg0)
}

// ExportClientVpnClientConfigurationRequest mocks base method.
func (m *MockEC2API) ExportClientVpnClientConfigurationRequest(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*request.Request, *ec2.ExportClientVpnClientConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ExportClientVpnClientConfigurationOutput)
	return ret0, ret1
}

// ExportClientVpnClientConfigurationRequest indicates an expected call of ExportClientVpnClientConfigurationRequest.
func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfigurationRequest), arg0)
}

// ExportClientVpnClientConfigurationWithContext mocks base method.
func (m *MockEC2API) ExportClientVpnClientConfigurationWithContext(arg0 context.Context, arg1 *ec2.ExportClientVpnClientConfigurationInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportImage mocks base method.
func (m *MockEC2API) ExportImage(arg0 *ec2.ExportImageInput) (*ec2.ExportImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportImage", arg0)
	ret0, _ := ret[0].(*ec2.ExportImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportImage indicates an expected call of ExportImage.
func (mr *MockEC2APIMockRecorder) ExportImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImage", reflect.TypeOf((*MockEC2API)(nil).ExportImage), arg0)
}

// ExportImageRequest mocks base method.
func (m *MockEC2API) ExportImageRequest(arg0 *ec2.ExportImageInput) (*request.Request, *ec2.ExportImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ExportImageOutput)
	return ret0, ret1
}

// ExportImageRequest indicates an expected call of ExportImageRequest.
func (mr *MockEC2APIMockRecorder) ExportImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ExportImageRequest), arg0)
}

// ExportImageWithContext mocks base method.
func (m *MockEC2API) ExportImageWithContext(arg0 context.Context, arg1 *ec2.ExportImageInput, arg2 ...request.Option) (*ec2.ExportImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ExportImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportTransitGatewayRoutes mocks base method.
func (m *MockEC2API) ExportTransitGatewayRoutes(arg0 *ec2.ExportTransitGatewayRoutesInput) (*ec2.ExportTransitGatewayRoutesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutes", arg0)
	ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportTransitGatewayRoutes indicates an expected call of ExportTransitGatewayRoutes.
func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutes), arg0)
}

// ExportTransitGatewayRoutesRequest mocks base method.
func (m *MockEC2API) ExportTransitGatewayRoutesRequest(arg0 *ec2.ExportTransitGatewayRoutesInput) (*request.Request, *ec2.ExportTransitGatewayRoutesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ExportTransitGatewayRoutesOutput)
	return ret0, ret1
}

// ExportTransitGatewayRoutesRequest indicates an expected call of ExportTransitGatewayRoutesRequest.
func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesRequest), arg0)
}

// ExportTransitGatewayRoutesWithContext mocks base method.
func (m *MockEC2API) ExportTransitGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.ExportTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.ExportTransitGatewayRoutesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAssociatedEnclaveCertificateIamRoles mocks base method.
func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRoles(arg0 *ec2.GetAssociatedEnclaveCertificateIamRolesInput) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRoles", arg0)
	ret0, _ := ret[0].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAssociatedEnclaveCertificateIamRoles indicates an expected call of GetAssociatedEnclaveCertificateIamRoles.
func (mr *MockEC2APIMockRecorder) GetAssociatedEnclaveCertificateIamRoles(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedEnclaveCertificateIamRoles", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedEnclaveCertificateIamRoles), arg0)
}

// GetAssociatedEnclaveCertificateIamRolesRequest mocks base method.
func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRolesRequest(arg0 *ec2.GetAssociatedEnclaveCertificateIamRolesInput) (*request.Request, *ec2.GetAssociatedEnclaveCertificateIamRolesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRolesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
	return ret0, ret1
}

// GetAssociatedEnclaveCertificateIamRolesRequest indicates an expected call of GetAssociatedEnclaveCertificateIamRolesRequest.
func (mr *MockEC2APIMockRecorder) GetAssociatedEnclaveCertificateIamRolesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedEnclaveCertificateIamRolesRequest", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedEnclaveCertificateIamRolesRequest), arg0)
}

// GetAssociatedEnclaveCertificateIamRolesWithContext mocks base method.
func (m *MockEC2API) GetAssociatedEnclaveCertificateIamRolesWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedEnclaveCertificateIamRolesInput, arg2 ...request.Option) (*ec2.GetAssociatedEnclaveCertificateIamRolesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAssociatedEnclaveCertificateIamRolesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetAssociatedEnclaveCertificateIamRolesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAssociatedIpv6PoolCidrs mocks base method.
func (m *MockEC2API) GetAssociatedIpv6PoolCidrs(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrs", arg0)
	ret0, _ := ret[0].(*ec2.GetAssociatedIpv6PoolCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAssociatedIpv6PoolCidrs indicates an expected call of GetAssociatedIpv6PoolCidrs.
func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrs", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrs), arg0)
}

// GetAssociatedIpv6PoolCidrsPages mocks base method.
func (m *MockEC2API) GetAssociatedIpv6PoolCidrsPages(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput, arg1 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetAssociatedIpv6PoolCidrsPages indicates an expected call of GetAssociatedIpv6PoolCidrsPages.
func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsPages), arg0, arg1)
}

// GetAssociatedIpv6PoolCidrsPagesWithContext mocks base method.
func (m *MockEC2API) GetAssociatedIpv6PoolCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedIpv6PoolCidrsInput, arg2 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetAssociatedIpv6PoolCidrsRequest mocks base method.
func (m *MockEC2API) GetAssociatedIpv6PoolCidrsRequest(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*request.Request, *ec2.GetAssociatedIpv6PoolCidrsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetAssociatedIpv6PoolCidrsOutput)
	return ret0, ret1
}

// GetAssociatedIpv6PoolCidrsRequest indicates an expected call of GetAssociatedIpv6PoolCidrsRequest.
func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsRequest), arg0)
}

// GetAssociatedIpv6PoolCidrsWithContext mocks base method.
func (m *MockEC2API) GetAssociatedIpv6PoolCidrsWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedIpv6PoolCidrsInput, arg2 ...request.Option) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetAssociatedIpv6PoolCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAwsNetworkPerformanceData mocks base method.
func (m *MockEC2API) GetAwsNetworkPerformanceData(arg0 *ec2.GetAwsNetworkPerformanceDataInput) (*ec2.GetAwsNetworkPerformanceDataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceData", arg0)
	ret0, _ := ret[0].(*ec2.GetAwsNetworkPerformanceDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAwsNetworkPerformanceData indicates an expected call of GetAwsNetworkPerformanceData.
func (mr *MockEC2APIMockRecorder) GetAwsNetworkPerformanceData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceData", reflect.TypeOf((*MockEC2API)(nil).GetAwsNetworkPerformanceData), arg0)
}

// GetAwsNetworkPerformanceDataPages mocks base method.
func (m *MockEC2API) GetAwsNetworkPerformanceDataPages(arg0 *ec2.GetAwsNetworkPerformanceDataInput, arg1 func(*ec2.GetAwsNetworkPerformanceDataOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetAwsNetworkPerformanceDataPages indicates an expected call of GetAwsNetworkPerformanceDataPages.
func (mr *MockEC2APIMockRecorder) GetAwsNetworkPerformanceDataPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceDataPages", reflect.TypeOf((*MockEC2API)(nil).GetAwsNetworkPerformanceDataPages), arg0, arg1)
}

// GetAwsNetworkPerformanceDataPagesWithContext mocks base method.
func (m *MockEC2API) GetAwsNetworkPerformanceDataPagesWithContext(arg0 context.Context, arg1 *ec2.GetAwsNetworkPerformanceDataInput, arg2 func(*ec2.GetAwsNetworkPerformanceDataOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetAwsNetworkPerformanceDataRequest mocks base method.
func (m *MockEC2API) GetAwsNetworkPerformanceDataRequest(arg0 *ec2.GetAwsNetworkPerformanceDataInput) (*request.Request, *ec2.GetAwsNetworkPerformanceDataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetAwsNetworkPerformanceDataOutput)
	return ret0, ret1
}

// GetAwsNetworkPerformanceDataRequest indicates an expected call of GetAwsNetworkPerformanceDataRequest.
func (mr *MockEC2APIMockRecorder) GetAwsNetworkPerformanceDataRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetAwsNetworkPerformanceDataRequest), arg0)
}

// GetAwsNetworkPerformanceDataWithContext mocks base method.
func (m *MockEC2API) GetAwsNetworkPerformanceDataWithContext(arg0 context.Context, arg1 *ec2.GetAwsNetworkPerformanceDataInput, arg2 ...request.Option) (*ec2.GetAwsNetworkPerformanceDataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetAwsNetworkPerformanceDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCapacityReservationUsage mocks base method.
func (m *MockEC2API) GetCapacityReservationUsage(arg0 *ec2.GetCapacityReservationUsageInput) (*ec2.GetCapacityReservationUsageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCapacityReservationUsage", arg0)
	ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCapacityReservationUsage indicates an expected call of GetCapacityReservationUsage.
func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsage", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsage), arg0)
}

// GetCapacityReservationUsageRequest mocks base method.
func (m *MockEC2API) GetCapacityReservationUsageRequest(arg0 *ec2.GetCapacityReservationUsageInput) (*request.Request, *ec2.GetCapacityReservationUsageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCapacityReservationUsageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetCapacityReservationUsageOutput)
	return ret0, ret1
}

// GetCapacityReservationUsageRequest indicates an expected call of GetCapacityReservationUsageRequest.
func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageRequest), arg0)
}

// GetCapacityReservationUsageWithContext mocks base method.
func (m *MockEC2API) GetCapacityReservationUsageWithContext(arg0 context.Context, arg1 *ec2.GetCapacityReservationUsageInput, arg2 ...request.Option) (*ec2.GetCapacityReservationUsageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCapacityReservationUsageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCoipPoolUsage mocks base method.
func (m *MockEC2API) GetCoipPoolUsage(arg0 *ec2.GetCoipPoolUsageInput) (*ec2.GetCoipPoolUsageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCoipPoolUsage", arg0)
	ret0, _ := ret[0].(*ec2.GetCoipPoolUsageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCoipPoolUsage indicates an expected call of GetCoipPoolUsage.
func (mr *MockEC2APIMockRecorder) GetCoipPoolUsage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsage", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsage), arg0)
}

// GetCoipPoolUsageRequest mocks base method.
func (m *MockEC2API) GetCoipPoolUsageRequest(arg0 *ec2.GetCoipPoolUsageInput) (*request.Request, *ec2.GetCoipPoolUsageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCoipPoolUsageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetCoipPoolUsageOutput)
	return ret0, ret1
}

// GetCoipPoolUsageRequest indicates an expected call of GetCoipPoolUsageRequest.
func (mr *MockEC2APIMockRecorder) GetCoipPoolUsageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsageRequest), arg0)
}

// GetCoipPoolUsageWithContext mocks base method.
func (m *MockEC2API) GetCoipPoolUsageWithContext(arg0 context.Context, arg1 *ec2.GetCoipPoolUsageInput, arg2 ...request.Option) (*ec2.GetCoipPoolUsageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCoipPoolUsageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetCoipPoolUsageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetConsoleOutput mocks base method.
func (m *MockEC2API) GetConsoleOutput(arg0 *ec2.GetConsoleOutputInput) (*ec2.GetConsoleOutputOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConsoleOutput", arg0)
	ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConsoleOutput indicates an expected call of GetConsoleOutput.
func (mr *MockEC2APIMockRecorder) GetConsoleOutput(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutput", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutput), arg0)
}

// GetConsoleOutputRequest mocks base method.
func (m *MockEC2API) GetConsoleOutputRequest(arg0 *ec2.GetConsoleOutputInput) (*request.Request, *ec2.GetConsoleOutputOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConsoleOutputRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetConsoleOutputOutput)
	return ret0, ret1
}

// GetConsoleOutputRequest indicates an expected call of GetConsoleOutputRequest.
func (mr *MockEC2APIMockRecorder) GetConsoleOutputRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutputRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutputRequest), arg0)
}

// GetConsoleOutputWithContext mocks base method.
func (m *MockEC2API) GetConsoleOutputWithContext(arg0 context.Context, arg1 *ec2.GetConsoleOutputInput, arg2 ...request.Option) (*ec2.GetConsoleOutputOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConsoleOutputWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetConsoleScreenshot mocks base method.
func (m *MockEC2API) GetConsoleScreenshot(arg0 *ec2.GetConsoleScreenshotInput) (*ec2.GetConsoleScreenshotOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConsoleScreenshot", arg0)
	ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConsoleScreenshot indicates an expected call of GetConsoleScreenshot.
func (mr *MockEC2APIMockRecorder) GetConsoleScreenshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshot", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshot), arg0)
}

// GetConsoleScreenshotRequest mocks base method.
func (m *MockEC2API) GetConsoleScreenshotRequest(arg0 *ec2.GetConsoleScreenshotInput) (*request.Request, *ec2.GetConsoleScreenshotOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConsoleScreenshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetConsoleScreenshotOutput)
	return ret0, ret1
}

// GetConsoleScreenshotRequest indicates an expected call of GetConsoleScreenshotRequest.
func (mr *MockEC2APIMockRecorder) GetConsoleScreenshotRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshotRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshotRequest), arg0)
}

// GetConsoleScreenshotWithContext mocks base method.
func (m *MockEC2API) GetConsoleScreenshotWithContext(arg0 context.Context, arg1 *ec2.GetConsoleScreenshotInput, arg2 ...request.Option) (*ec2.GetConsoleScreenshotOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConsoleScreenshotWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDefaultCreditSpecification mocks base method.
func (m *MockEC2API) GetDefaultCreditSpecification(arg0 *ec2.GetDefaultCreditSpecificationInput) (*ec2.GetDefaultCreditSpecificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultCreditSpecification", arg0)
	ret0, _ := ret[0].(*ec2.GetDefaultCreditSpecificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultCreditSpecification indicates an expected call of GetDefaultCreditSpecification.
func (mr *MockEC2APIMockRecorder) GetDefaultCreditSpecification(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecification), arg0)
}

// GetDefaultCreditSpecificationRequest mocks base method.
func (m *MockEC2API) GetDefaultCreditSpecificationRequest(arg0 *ec2.GetDefaultCreditSpecificationInput) (*request.Request, *ec2.GetDefaultCreditSpecificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultCreditSpecificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetDefaultCreditSpecificationOutput)
	return ret0, ret1
}

// GetDefaultCreditSpecificationRequest indicates an expected call of GetDefaultCreditSpecificationRequest.
func (mr *MockEC2APIMockRecorder) GetDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecificationRequest), arg0)
}

// GetDefaultCreditSpecificationWithContext mocks base method.
func (m *MockEC2API) GetDefaultCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.GetDefaultCreditSpecificationInput, arg2 ...request.Option) (*ec2.GetDefaultCreditSpecificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDefaultCreditSpecificationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetDefaultCreditSpecificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEbsDefaultKmsKeyId mocks base method.
func (m *MockEC2API) GetEbsDefaultKmsKeyId(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyId", arg0)
	ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEbsDefaultKmsKeyId indicates an expected call of GetEbsDefaultKmsKeyId.
func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyId), arg0)
}

// GetEbsDefaultKmsKeyIdRequest mocks base method.
func (m *MockEC2API) GetEbsDefaultKmsKeyIdRequest(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.GetEbsDefaultKmsKeyIdOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetEbsDefaultKmsKeyIdOutput)
	return ret0, ret1
}

// GetEbsDefaultKmsKeyIdRequest indicates an expected call of GetEbsDefaultKmsKeyIdRequest.
func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdRequest), arg0)
}

// GetEbsDefaultKmsKeyIdWithContext mocks base method.
func (m *MockEC2API) GetEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.GetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEbsEncryptionByDefault mocks base method.
func (m *MockEC2API) GetEbsEncryptionByDefault(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*ec2.GetEbsEncryptionByDefaultOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEbsEncryptionByDefault", arg0)
	ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEbsEncryptionByDefault indicates an expected call of GetEbsEncryptionByDefault.
func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefault(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefault), arg0)
}

// GetEbsEncryptionByDefaultRequest mocks base method.
func (m *MockEC2API) GetEbsEncryptionByDefaultRequest(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*request.Request, *ec2.GetEbsEncryptionByDefaultOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetEbsEncryptionByDefaultOutput)
	return ret0, ret1
}

// GetEbsEncryptionByDefaultRequest indicates an expected call of GetEbsEncryptionByDefaultRequest.
func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultRequest), arg0)
}

// GetEbsEncryptionByDefaultWithContext mocks base method.
func (m *MockEC2API) GetEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.GetEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.GetEbsEncryptionByDefaultOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFlowLogsIntegrationTemplate mocks base method.
func (m *MockEC2API) GetFlowLogsIntegrationTemplate(arg0 *ec2.GetFlowLogsIntegrationTemplateInput) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplate", arg0)
	ret0, _ := ret[0].(*ec2.GetFlowLogsIntegrationTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFlowLogsIntegrationTemplate indicates an expected call of GetFlowLogsIntegrationTemplate.
func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplate", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplate), arg0)
}

// GetFlowLogsIntegrationTemplateRequest mocks base method.
func (m *MockEC2API) GetFlowLogsIntegrationTemplateRequest(arg0 *ec2.GetFlowLogsIntegrationTemplateInput) (*request.Request, *ec2.GetFlowLogsIntegrationTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetFlowLogsIntegrationTemplateOutput)
	return ret0, ret1
}

// GetFlowLogsIntegrationTemplateRequest indicates an expected call of GetFlowLogsIntegrationTemplateRequest.
func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplateRequest), arg0)
}

// GetFlowLogsIntegrationTemplateWithContext mocks base method.
func (m *MockEC2API) GetFlowLogsIntegrationTemplateWithContext(arg0 context.Context, arg1 *ec2.GetFlowLogsIntegrationTemplateInput, arg2 ...request.Option) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetFlowLogsIntegrationTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGroupsForCapacityReservation mocks base method.
func (m *MockEC2API) GetGroupsForCapacityReservation(arg0 *ec2.GetGroupsForCapacityReservationInput) (*ec2.GetGroupsForCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservation", arg0)
	ret0, _ := ret[0].(*ec2.GetGroupsForCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupsForCapacityReservation indicates an expected call of GetGroupsForCapacityReservation.
func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservation), arg0)
}

// GetGroupsForCapacityReservationPages mocks base method.
func (m *MockEC2API) GetGroupsForCapacityReservationPages(arg0 *ec2.GetGroupsForCapacityReservationInput, arg1 func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetGroupsForCapacityReservationPages indicates an expected call of GetGroupsForCapacityReservationPages.
func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationPages", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationPages), arg0, arg1)
}

// GetGroupsForCapacityReservationPagesWithContext mocks base method.
func (m *MockEC2API) GetGroupsForCapacityReservationPagesWithContext(arg0 context.Context, arg1 *ec2.GetGroupsForCapacityReservationInput, arg2 func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetGroupsForCapacityReservationRequest mocks base method.
func (m *MockEC2API) GetGroupsForCapacityReservationRequest(arg0 *ec2.GetGroupsForCapacityReservationInput) (*request.Request, *ec2.GetGroupsForCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetGroupsForCapacityReservationOutput)
	return ret0, ret1
}

// GetGroupsForCapacityReservationRequest indicates an expected call of GetGroupsForCapacityReservationRequest.
func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationRequest), arg0)
}

// GetGroupsForCapacityReservationWithContext mocks base method.
func (m *MockEC2API) GetGroupsForCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.GetGroupsForCapacityReservationInput, arg2 ...request.Option) (*ec2.GetGroupsForCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetGroupsForCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetHostReservationPurchasePreview mocks base method.
func (m *MockEC2API) GetHostReservationPurchasePreview(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*ec2.GetHostReservationPurchasePreviewOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostReservationPurchasePreview", arg0)
	ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostReservationPurchasePreview indicates an expected call of GetHostReservationPurchasePreview.
func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreview(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreview", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreview), arg0)
}

// GetHostReservationPurchasePreviewRequest mocks base method.
func (m *MockEC2API) GetHostReservationPurchasePreviewRequest(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*request.Request, *ec2.GetHostReservationPurchasePreviewOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetHostReservationPurchasePreviewOutput)
	return ret0, ret1
}

// GetHostReservationPurchasePreviewRequest indicates an expected call of GetHostReservationPurchasePreviewRequest.
func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreviewRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreviewRequest", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreviewRequest), arg0)
}

// GetHostReservationPurchasePreviewWithContext mocks base method.
func (m *MockEC2API) GetHostReservationPurchasePreviewWithContext(arg0 context.Context, arg1 *ec2.GetHostReservationPurchasePreviewInput, arg2 ...request.Option) (*ec2.GetHostReservationPurchasePreviewOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetImageBlockPublicAccessState mocks base method.
func (m *MockEC2API) GetImageBlockPublicAccessState(arg0 *ec2.GetImageBlockPublicAccessStateInput) (*ec2.GetImageBlockPublicAccessStateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImageBlockPublicAccessState", arg0)
	ret0, _ := ret[0].(*ec2.GetImageBlockPublicAccessStateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageBlockPublicAccessState indicates an expected call of GetImageBlockPublicAccessState.
func (mr *MockEC2APIMockRecorder) GetImageBlockPublicAccessState(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageBlockPublicAccessState", reflect.TypeOf((*MockEC2API)(nil).GetImageBlockPublicAccessState), arg0)
}

// GetImageBlockPublicAccessStateRequest mocks base method.
func (m *MockEC2API) GetImageBlockPublicAccessStateRequest(arg0 *ec2.GetImageBlockPublicAccessStateInput) (*request.Request, *ec2.GetImageBlockPublicAccessStateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImageBlockPublicAccessStateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetImageBlockPublicAccessStateOutput)
	return ret0, ret1
}

// GetImageBlockPublicAccessStateRequest indicates an expected call of GetImageBlockPublicAccessStateRequest.
func (mr *MockEC2APIMockRecorder) GetImageBlockPublicAccessStateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageBlockPublicAccessStateRequest", reflect.TypeOf((*MockEC2API)(nil).GetImageBlockPublicAccessStateRequest), arg0)
}

// GetImageBlockPublicAccessStateWithContext mocks base method.
func (m *MockEC2API) GetImageBlockPublicAccessStateWithContext(arg0 context.Context, arg1 *ec2.GetImageBlockPublicAccessStateInput, arg2 ...request.Option) (*ec2.GetImageBlockPublicAccessStateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetImageBlockPublicAccessStateWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetImageBlockPublicAccessStateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceMetadataDefaults mocks base method.
func (m *MockEC2API) GetInstanceMetadataDefaults(arg0 *ec2.GetInstanceMetadataDefaultsInput) (*ec2.GetInstanceMetadataDefaultsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceMetadataDefaults", arg0)
	ret0, _ := ret[0].(*ec2.GetInstanceMetadataDefaultsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceMetadataDefaults indicates an expected call of GetInstanceMetadataDefaults.
func (mr *MockEC2APIMockRecorder) GetInstanceMetadataDefaults(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceMetadataDefaults", reflect.TypeOf((*MockEC2API)(nil).GetInstanceMetadataDefaults), arg0)
}

// GetInstanceMetadataDefaultsRequest mocks base method.
func (m *MockEC2API) GetInstanceMetadataDefaultsRequest(arg0 *ec2.GetInstanceMetadataDefaultsInput) (*request.Request, *ec2.GetInstanceMetadataDefaultsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceMetadataDefaultsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetInstanceMetadataDefaultsOutput)
	return ret0, ret1
}

// GetInstanceMetadataDefaultsRequest indicates an expected call of GetInstanceMetadataDefaultsRequest.
func (mr *MockEC2APIMockRecorder) GetInstanceMetadataDefaultsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceMetadataDefaultsRequest", reflect.TypeOf((*MockEC2API)(nil).GetInstanceMetadataDefaultsRequest), arg0)
}

// GetInstanceMetadataDefaultsWithContext mocks base method.
func (m *MockEC2API) GetInstanceMetadataDefaultsWithContext(arg0 context.Context, arg1 *ec2.GetInstanceMetadataDefaultsInput, arg2 ...request.Option) (*ec2.GetInstanceMetadataDefaultsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInstanceMetadataDefaultsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetInstanceMetadataDefaultsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceTpmEkPub mocks base method.
func (m *MockEC2API) GetInstanceTpmEkPub(arg0 *ec2.GetInstanceTpmEkPubInput) (*ec2.GetInstanceTpmEkPubOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceTpmEkPub", arg0)
	ret0, _ := ret[0].(*ec2.GetInstanceTpmEkPubOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceTpmEkPub indicates an expected call of GetInstanceTpmEkPub.
func (mr *MockEC2APIMockRecorder) GetInstanceTpmEkPub(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTpmEkPub", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTpmEkPub), arg0)
}

// GetInstanceTpmEkPubRequest mocks base method.
func (m *MockEC2API) GetInstanceTpmEkPubRequest(arg0 *ec2.GetInstanceTpmEkPubInput) (*request.Request, *ec2.GetInstanceTpmEkPubOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceTpmEkPubRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetInstanceTpmEkPubOutput)
	return ret0, ret1
}

// GetInstanceTpmEkPubRequest indicates an expected call of GetInstanceTpmEkPubRequest.
func (mr *MockEC2APIMockRecorder) GetInstanceTpmEkPubRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTpmEkPubRequest", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTpmEkPubRequest), arg0)
}

// GetInstanceTpmEkPubWithContext mocks base method.
func (m *MockEC2API) GetInstanceTpmEkPubWithContext(arg0 context.Context, arg1 *ec2.GetInstanceTpmEkPubInput, arg2 ...request.Option) (*ec2.GetInstanceTpmEkPubOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInstanceTpmEkPubWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetInstanceTpmEkPubOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceTypesFromInstanceRequirements mocks base method.
func (m *MockEC2API) GetInstanceTypesFromInstanceRequirements(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirements", arg0)
	ret0, _ := ret[0].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceTypesFromInstanceRequirements indicates an expected call of GetInstanceTypesFromInstanceRequirements.
func (mr *MockEC2APIMockRecorder) GetInstanceTypesFromInstanceRequirements(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirements", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTypesFromInstanceRequirements), arg0)
}

// GetInstanceTypesFromInstanceRequirementsPages mocks base method.
func (m *MockEC2API) GetInstanceTypesFromInstanceRequirementsPages(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg1 func(*ec2.GetInstanceTypesFromInstanceRequirementsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetInstanceTypesFromInstanceRequirementsPages indicates an expected call of GetInstanceTypesFromInstanceRequirementsPages.
func (mr *MockEC2APIMockRecorder) GetInstanceTypesFromInstanceRequirementsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirementsPages", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTypesFromInstanceRequirementsPages), arg0, arg1)
}

// GetInstanceTypesFromInstanceRequirementsPagesWithContext mocks base method.
func (m *MockEC2API) GetInstanceTypesFromInstanceRequirementsPagesWithContext(arg0 context.Context, arg1 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg2 func(*ec2.GetInstanceTypesFromInstanceRequirementsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetInstanceTypesFromInstanceRequirementsRequest mocks base method.
func (m *MockEC2API) GetInstanceTypesFromInstanceRequirementsRequest(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput) (*request.Request, *ec2.GetInstanceTypesFromInstanceRequirementsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput)
	return ret0, ret1
}

// GetInstanceTypesFromInstanceRequirementsRequest indicates an expected call of GetInstanceTypesFromInstanceRequirementsRequest.
func (mr *MockEC2APIMockRecorder) GetInstanceTypesFromInstanceRequirementsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirementsRequest", reflect.TypeOf((*MockEC2API)(nil).GetInstanceTypesFromInstanceRequirementsRequest), arg0)
}

// GetInstanceTypesFromInstanceRequirementsWithContext mocks base method.
func (m *MockEC2API) GetInstanceTypesFromInstanceRequirementsWithContext(arg0 context.Context, arg1 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg2 ...request.Option) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceUefiData mocks base method.
func (m *MockEC2API) GetInstanceUefiData(arg0 *ec2.GetInstanceUefiDataInput) (*ec2.GetInstanceUefiDataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceUefiData", arg0)
	ret0, _ := ret[0].(*ec2.GetInstanceUefiDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceUefiData indicates an expected call of GetInstanceUefiData.
func (mr *MockEC2APIMockRecorder) GetInstanceUefiData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceUefiData", reflect.TypeOf((*MockEC2API)(nil).GetInstanceUefiData), arg0)
}

// GetInstanceUefiDataRequest mocks base method.
func (m *MockEC2API) GetInstanceUefiDataRequest(arg0 *ec2.GetInstanceUefiDataInput) (*request.Request, *ec2.GetInstanceUefiDataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceUefiDataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetInstanceUefiDataOutput)
	return ret0, ret1
}

// GetInstanceUefiDataRequest indicates an expected call of GetInstanceUefiDataRequest.
func (mr *MockEC2APIMockRecorder) GetInstanceUefiDataRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceUefiDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetInstanceUefiDataRequest), arg0)
}

// GetInstanceUefiDataWithContext mocks base method.
func (m *MockEC2API) GetInstanceUefiDataWithContext(arg0 context.Context, arg1 *ec2.GetInstanceUefiDataInput, arg2 ...request.Option) (*ec2.GetInstanceUefiDataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInstanceUefiDataWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetInstanceUefiDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIpamAddressHistory mocks base method.
func (m *MockEC2API) GetIpamAddressHistory(arg0 *ec2.GetIpamAddressHistoryInput) (*ec2.GetIpamAddressHistoryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamAddressHistory", arg0)
	ret0, _ := ret[0].(*ec2.GetIpamAddressHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIpamAddressHistory indicates an expected call of GetIpamAddressHistory.
func (mr *MockEC2APIMockRecorder) GetIpamAddressHistory(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistory", reflect.TypeOf((*MockEC2API)(nil).GetIpamAddressHistory), arg0)
}

// GetIpamAddressHistoryPages mocks base method.
func (m *MockEC2API) GetIpamAddressHistoryPages(arg0 *ec2.GetIpamAddressHistoryInput, arg1 func(*ec2.GetIpamAddressHistoryOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamAddressHistoryPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetIpamAddressHistoryPages indicates an expected call of GetIpamAddressHistoryPages.
func (mr *MockEC2APIMockRecorder) GetIpamAddressHistoryPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistoryPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamAddressHistoryPages), arg0, arg1)
}

// GetIpamAddressHistoryPagesWithContext mocks base method.
func (m *MockEC2API) GetIpamAddressHistoryPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamAddressHistoryInput, arg2 func(*ec2.GetIpamAddressHistoryOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamAddressHistoryPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetIpamAddressHistoryRequest mocks base method.
func (m *MockEC2API) GetIpamAddressHistoryRequest(arg0 *ec2.GetIpamAddressHistoryInput) (*request.Request, *ec2.GetIpamAddressHistoryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamAddressHistoryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetIpamAddressHistoryOutput)
	return ret0, ret1
}

// GetIpamAddressHistoryRequest indicates an expected call of GetIpamAddressHistoryRequest.
func (mr *MockEC2APIMockRecorder) GetIpamAddressHistoryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamAddressHistoryRequest), arg0)
}

// GetIpamAddressHistoryWithContext mocks base method.
func (m *MockEC2API) GetIpamAddressHistoryWithContext(arg0 context.Context, arg1 *ec2.GetIpamAddressHistoryInput, arg2 ...request.Option) (*ec2.GetIpamAddressHistoryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamAddressHistoryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetIpamAddressHistoryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIpamDiscoveredAccounts mocks base method.
func (m *MockEC2API) GetIpamDiscoveredAccounts(arg0 *ec2.GetIpamDiscoveredAccountsInput) (*ec2.GetIpamDiscoveredAccountsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccounts", arg0)
	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredAccountsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIpamDiscoveredAccounts indicates an expected call of GetIpamDiscoveredAccounts.
func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredAccounts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccounts", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredAccounts), arg0)
}

// GetIpamDiscoveredAccountsPages mocks base method.
func (m *MockEC2API) GetIpamDiscoveredAccountsPages(arg0 *ec2.GetIpamDiscoveredAccountsInput, arg1 func(*ec2.GetIpamDiscoveredAccountsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetIpamDiscoveredAccountsPages indicates an expected call of GetIpamDiscoveredAccountsPages.
func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredAccountsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccountsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredAccountsPages), arg0, arg1)
}

// GetIpamDiscoveredAccountsPagesWithContext mocks base method.
func (m *MockEC2API) GetIpamDiscoveredAccountsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredAccountsInput, arg2 func(*ec2.GetIpamDiscoveredAccountsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetIpamDiscoveredAccountsRequest mocks base method.
func (m *MockEC2API) GetIpamDiscoveredAccountsRequest(arg0 *ec2.GetIpamDiscoveredAccountsInput) (*request.Request, *ec2.GetIpamDiscoveredAccountsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetIpamDiscoveredAccountsOutput)
	return ret0, ret1
}

// GetIpamDiscoveredAccountsRequest indicates an expected call of GetIpamDiscoveredAccountsRequest.
func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredAccountsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccountsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredAccountsRequest), arg0)
}

// GetIpamDiscoveredAccountsWithContext mocks base method.
func (m *MockEC2API) GetIpamDiscoveredAccountsWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredAccountsInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredAccountsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredAccountsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIpamDiscoveredPublicAddresses mocks base method.
func (m *MockEC2API) GetIpamDiscoveredPublicAddresses(arg0 *ec2.GetIpamDiscoveredPublicAddressesInput) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddresses", arg0)
	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredPublicAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIpamDiscoveredPublicAddresses indicates an expected call of GetIpamDiscoveredPublicAddresses.
func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredPublicAddresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredPublicAddresses", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredPublicAddresses), arg0)
}

// GetIpamDiscoveredPublicAddressesRequest mocks base method.
func (m *MockEC2API) GetIpamDiscoveredPublicAddressesRequest(arg0 *ec2.GetIpamDiscoveredPublicAddressesInput) (*request.Request, *ec2.GetIpamDiscoveredPublicAddressesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddressesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetIpamDiscoveredPublicAddressesOutput)
	return ret0, ret1
}

// GetIpamDiscoveredPublicAddressesRequest indicates an expected call of GetIpamDiscoveredPublicAddressesRequest.
func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredPublicAddressesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredPublicAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredPublicAddressesRequest), arg0)
}

// GetIpamDiscoveredPublicAddressesWithContext mocks base method.
func (m *MockEC2API) GetIpamDiscoveredPublicAddressesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredPublicAddressesInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddressesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredPublicAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIpamDiscoveredResourceCidrs mocks base method.
func (m *MockEC2API) GetIpamDiscoveredResourceCidrs(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrs", arg0)
	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredResourceCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIpamDiscoveredResourceCidrs indicates an expected call of GetIpamDiscoveredResourceCidrs.
func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredResourceCidrs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrs", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredResourceCidrs), arg0)
}

// GetIpamDiscoveredResourceCidrsPages mocks base method.
func (m *MockEC2API) GetIpamDiscoveredResourceCidrsPages(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput, arg1 func(*ec2.GetIpamDiscoveredResourceCidrsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetIpamDiscoveredResourceCidrsPages indicates an expected call of GetIpamDiscoveredResourceCidrsPages.
func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredResourceCidrsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredResourceCidrsPages), arg0, arg1)
}

// GetIpamDiscoveredResourceCidrsPagesWithContext mocks base method.
func (m *MockEC2API) GetIpamDiscoveredResourceCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredResourceCidrsInput, arg2 func(*ec2.GetIpamDiscoveredResourceCidrsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetIpamDiscoveredResourceCidrsRequest mocks base method.
func (m *MockEC2API) GetIpamDiscoveredResourceCidrsRequest(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput) (*request.Request, *ec2.GetIpamDiscoveredResourceCidrsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetIpamDiscoveredResourceCidrsOutput)
	return ret0, ret1
}

// GetIpamDiscoveredResourceCidrsRequest indicates an expected call of GetIpamDiscoveredResourceCidrsRequest.
func (mr *MockEC2APIMockRecorder) GetIpamDiscoveredResourceCidrsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamDiscoveredResourceCidrsRequest), arg0)
}

// GetIpamDiscoveredResourceCidrsWithContext mocks base method.
func (m *MockEC2API) GetIpamDiscoveredResourceCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredResourceCidrsInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetIpamDiscoveredResourceCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIpamPoolAllocations mocks base method.
func (m *MockEC2API) GetIpamPoolAllocations(arg0 *ec2.GetIpamPoolAllocationsInput) (*ec2.GetIpamPoolAllocationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamPoolAllocations", arg0)
	ret0, _ := ret[0].(*ec2.GetIpamPoolAllocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIpamPoolAllocations indicates an expected call of GetIpamPoolAllocations.
func (mr *MockEC2APIMockRecorder) GetIpamPoolAllocations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocations", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolAllocations), arg0)
}

// GetIpamPoolAllocationsPages mocks base method.
func (m *MockEC2API) GetIpamPoolAllocationsPages(arg0 *ec2.GetIpamPoolAllocationsInput, arg1 func(*ec2.GetIpamPoolAllocationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamPoolAllocationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetIpamPoolAllocationsPages indicates an expected call of GetIpamPoolAllocationsPages.
func (mr *MockEC2APIMockRecorder) GetIpamPoolAllocationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocationsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolAllocationsPages), arg0, arg1)
}

// GetIpamPoolAllocationsPagesWithContext mocks base method.
func (m *MockEC2API) GetIpamPoolAllocationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolAllocationsInput, arg2 func(*ec2.GetIpamPoolAllocationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamPoolAllocationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetIpamPoolAllocationsRequest mocks base method.
func (m *MockEC2API) GetIpamPoolAllocationsRequest(arg0 *ec2.GetIpamPoolAllocationsInput) (*request.Request, *ec2.GetIpamPoolAllocationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamPoolAllocationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetIpamPoolAllocationsOutput)
	return ret0, ret1
}

// GetIpamPoolAllocationsRequest indicates an expected call of GetIpamPoolAllocationsRequest.
func (mr *MockEC2APIMockRecorder) GetIpamPoolAllocationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolAllocationsRequest), arg0)
}

// GetIpamPoolAllocationsWithContext mocks base method.
func (m *MockEC2API) GetIpamPoolAllocationsWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolAllocationsInput, arg2 ...request.Option) (*ec2.GetIpamPoolAllocationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamPoolAllocationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetIpamPoolAllocationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIpamPoolCidrs mocks base method.
func (m *MockEC2API) GetIpamPoolCidrs(arg0 *ec2.GetIpamPoolCidrsInput) (*ec2.GetIpamPoolCidrsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamPoolCidrs", arg0)
	ret0, _ := ret[0].(*ec2.GetIpamPoolCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIpamPoolCidrs indicates an expected call of GetIpamPoolCidrs.
func (mr *MockEC2APIMockRecorder) GetIpamPoolCidrs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrs", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolCidrs), arg0)
}

// GetIpamPoolCidrsPages mocks base method.
func (m *MockEC2API) GetIpamPoolCidrsPages(arg0 *ec2.GetIpamPoolCidrsInput, arg1 func(*ec2.GetIpamPoolCidrsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamPoolCidrsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetIpamPoolCidrsPages indicates an expected call of GetIpamPoolCidrsPages.
func (mr *MockEC2APIMockRecorder) GetIpamPoolCidrsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolCidrsPages), arg0, arg1)
}

// GetIpamPoolCidrsPagesWithContext mocks base method.
func (m *MockEC2API) GetIpamPoolCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolCidrsInput, arg2 func(*ec2.GetIpamPoolCidrsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamPoolCidrsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetIpamPoolCidrsRequest mocks base method.
func (m *MockEC2API) GetIpamPoolCidrsRequest(arg0 *ec2.GetIpamPoolCidrsInput) (*request.Request, *ec2.GetIpamPoolCidrsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamPoolCidrsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetIpamPoolCidrsOutput)
	return ret0, ret1
}

// GetIpamPoolCidrsRequest indicates an expected call of GetIpamPoolCidrsRequest.
func (mr *MockEC2APIMockRecorder) GetIpamPoolCidrsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamPoolCidrsRequest), arg0)
}

// GetIpamPoolCidrsWithContext mocks base method.
func (m *MockEC2API) GetIpamPoolCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolCidrsInput, arg2 ...request.Option) (*ec2.GetIpamPoolCidrsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamPoolCidrsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetIpamPoolCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIpamResourceCidrs mocks base method.
func (m *MockEC2API) GetIpamResourceCidrs(arg0 *ec2.GetIpamResourceCidrsInput) (*ec2.GetIpamResourceCidrsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamResourceCidrs", arg0)
	ret0, _ := ret[0].(*ec2.GetIpamResourceCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIpamResourceCidrs indicates an expected call of GetIpamResourceCidrs.
func (mr *MockEC2APIMockRecorder) GetIpamResourceCidrs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrs", reflect.TypeOf((*MockEC2API)(nil).GetIpamResourceCidrs), arg0)
}

// GetIpamResourceCidrsPages mocks base method.
func (m *MockEC2API) GetIpamResourceCidrsPages(arg0 *ec2.GetIpamResourceCidrsInput, arg1 func(*ec2.GetIpamResourceCidrsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamResourceCidrsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetIpamResourceCidrsPages indicates an expected call of GetIpamResourceCidrsPages.
func (mr *MockEC2APIMockRecorder) GetIpamResourceCidrsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetIpamResourceCidrsPages), arg0, arg1)
}

// GetIpamResourceCidrsPagesWithContext mocks base method.
func (m *MockEC2API) GetIpamResourceCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamResourceCidrsInput, arg2 func(*ec2.GetIpamResourceCidrsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamResourceCidrsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetIpamResourceCidrsRequest mocks base method.
func (m *MockEC2API) GetIpamResourceCidrsRequest(arg0 *ec2.GetIpamResourceCidrsInput) (*request.Request, *ec2.GetIpamResourceCidrsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIpamResourceCidrsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetIpamResourceCidrsOutput)
	return ret0, ret1
}

// GetIpamResourceCidrsRequest indicates an expected call of GetIpamResourceCidrsRequest.
func (mr *MockEC2APIMockRecorder) GetIpamResourceCidrsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetIpamResourceCidrsRequest), arg0)
}

// GetIpamResourceCidrsWithContext mocks base method.
func (m *MockEC2API) GetIpamResourceCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamResourceCidrsInput, arg2 ...request.Option) (*ec2.GetIpamResourceCidrsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIpamResourceCidrsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetIpamResourceCidrsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLaunchTemplateData mocks base method.
func (m *MockEC2API) GetLaunchTemplateData(arg0 *ec2.GetLaunchTemplateDataInput) (*ec2.GetLaunchTemplateDataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLaunchTemplateData", arg0)
	ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLaunchTemplateData indicates an expected call of GetLaunchTemplateData.
func (mr *MockEC2APIMockRecorder) GetLaunchTemplateData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateData", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateData), arg0)
}

// GetLaunchTemplateDataRequest mocks base method.
func (m *MockEC2API) GetLaunchTemplateDataRequest(arg0 *ec2.GetLaunchTemplateDataInput) (*request.Request, *ec2.GetLaunchTemplateDataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLaunchTemplateDataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetLaunchTemplateDataOutput)
	return ret0, ret1
}

// GetLaunchTemplateDataRequest indicates an expected call of GetLaunchTemplateDataRequest.
func (mr *MockEC2APIMockRecorder) GetLaunchTemplateDataRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateDataRequest), arg0)
}

// GetLaunchTemplateDataWithContext mocks base method.
func (m *MockEC2API) GetLaunchTemplateDataWithContext(arg0 context.Context, arg1 *ec2.GetLaunchTemplateDataInput, arg2 ...request.Option) (*ec2.GetLaunchTemplateDataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLaunchTemplateDataWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetManagedPrefixListAssociations mocks base method.
func (m *MockEC2API) GetManagedPrefixListAssociations(arg0 *ec2.GetManagedPrefixListAssociationsInput) (*ec2.GetManagedPrefixListAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociations", arg0)
	ret0, _ := ret[0].(*ec2.GetManagedPrefixListAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetManagedPrefixListAssociations indicates an expected call of GetManagedPrefixListAssociations.
func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociations", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociations), arg0)
}

// GetManagedPrefixListAssociationsPages mocks base method.
func (m *MockEC2API) GetManagedPrefixListAssociationsPages(arg0 *ec2.GetManagedPrefixListAssociationsInput, arg1 func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetManagedPrefixListAssociationsPages indicates an expected call of GetManagedPrefixListAssociationsPages.
func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsPages), arg0, arg1)
}

// GetManagedPrefixListAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) GetManagedPrefixListAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListAssociationsInput, arg2 func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetManagedPrefixListAssociationsRequest mocks base method.
func (m *MockEC2API) GetManagedPrefixListAssociationsRequest(arg0 *ec2.GetManagedPrefixListAssociationsInput) (*request.Request, *ec2.GetManagedPrefixListAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetManagedPrefixListAssociationsOutput)
	return ret0, ret1
}

// GetManagedPrefixListAssociationsRequest indicates an expected call of GetManagedPrefixListAssociationsRequest.
func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsRequest), arg0)
}

// GetManagedPrefixListAssociationsWithContext mocks base method.
func (m *MockEC2API) GetManagedPrefixListAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListAssociationsInput, arg2 ...request.Option) (*ec2.GetManagedPrefixListAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetManagedPrefixListAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetManagedPrefixListEntries mocks base method.
func (m *MockEC2API) GetManagedPrefixListEntries(arg0 *ec2.GetManagedPrefixListEntriesInput) (*ec2.GetManagedPrefixListEntriesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManagedPrefixListEntries", arg0)
	ret0, _ := ret[0].(*ec2.GetManagedPrefixListEntriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetManagedPrefixListEntries indicates an expected call of GetManagedPrefixListEntries.
func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntries(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntries", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntries), arg0)
}

// GetManagedPrefixListEntriesPages mocks base method.
func (m *MockEC2API) GetManagedPrefixListEntriesPages(arg0 *ec2.GetManagedPrefixListEntriesInput, arg1 func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetManagedPrefixListEntriesPages indicates an expected call of GetManagedPrefixListEntriesPages.
func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesPages", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesPages), arg0, arg1)
}

// GetManagedPrefixListEntriesPagesWithContext mocks base method.
func (m *MockEC2API) GetManagedPrefixListEntriesPagesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListEntriesInput, arg2 func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetManagedPrefixListEntriesRequest mocks base method.
func (m *MockEC2API) GetManagedPrefixListEntriesRequest(arg0 *ec2.GetManagedPrefixListEntriesInput) (*request.Request, *ec2.GetManagedPrefixListEntriesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetManagedPrefixListEntriesOutput)
	return ret0, ret1
}

// GetManagedPrefixListEntriesRequest indicates an expected call of GetManagedPrefixListEntriesRequest.
func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesRequest", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesRequest), arg0)
}

// GetManagedPrefixListEntriesWithContext mocks base method.
func (m *MockEC2API) GetManagedPrefixListEntriesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListEntriesInput, arg2 ...request.Option) (*ec2.GetManagedPrefixListEntriesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetManagedPrefixListEntriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkInsightsAccessScopeAnalysisFindings mocks base method.
func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindings(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindings", arg0)
	ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetworkInsightsAccessScopeAnalysisFindings indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindings.
func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeAnalysisFindings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindings", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeAnalysisFindings), arg0)
}

// GetNetworkInsightsAccessScopeAnalysisFindingsPages mocks base method.
func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindingsPages(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg1 func(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetNetworkInsightsAccessScopeAnalysisFindingsPages indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsPages.
func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindingsPages", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsPages), arg0, arg1)
}

// GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext mocks base method.
func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg2 func(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetNetworkInsightsAccessScopeAnalysisFindingsRequest mocks base method.
func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindingsRequest(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput) (*request.Request, *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput)
	return ret0, ret1
}

// GetNetworkInsightsAccessScopeAnalysisFindingsRequest indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsRequest.
func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindingsRequest", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsRequest), arg0)
}

// GetNetworkInsightsAccessScopeAnalysisFindingsWithContext mocks base method.
func (m *MockEC2API) GetNetworkInsightsAccessScopeAnalysisFindingsWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg2 ...request.Option) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkInsightsAccessScopeContent mocks base method.
func (m *MockEC2API) GetNetworkInsightsAccessScopeContent(arg0 *ec2.GetNetworkInsightsAccessScopeContentInput) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContent", arg0)
	ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeContentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetworkInsightsAccessScopeContent indicates an expected call of GetNetworkInsightsAccessScopeContent.
func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeContent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeContent", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeContent), arg0)
}

// GetNetworkInsightsAccessScopeContentRequest mocks base method.
func (m *MockEC2API) GetNetworkInsightsAccessScopeContentRequest(arg0 *ec2.GetNetworkInsightsAccessScopeContentInput) (*request.Request, *ec2.GetNetworkInsightsAccessScopeContentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetNetworkInsightsAccessScopeContentOutput)
	return ret0, ret1
}

// GetNetworkInsightsAccessScopeContentRequest indicates an expected call of GetNetworkInsightsAccessScopeContentRequest.
func (mr *MockEC2APIMockRecorder) GetNetworkInsightsAccessScopeContentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeContentRequest", reflect.TypeOf((*MockEC2API)(nil).GetNetworkInsightsAccessScopeContentRequest), arg0)
}

// GetNetworkInsightsAccessScopeContentWithContext mocks base method.
func (m *MockEC2API) GetNetworkInsightsAccessScopeContentWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeContentInput, arg2 ...request.Option) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeContentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPasswordData mocks base method.
func (m *MockEC2API) GetPasswordData(arg0 *ec2.GetPasswordDataInput) (*ec2.GetPasswordDataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPasswordData", arg0)
	ret0, _ := ret[0].(*ec2.GetPasswordDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPasswordData indicates an expected call of GetPasswordData.
func (mr *MockEC2APIMockRecorder) GetPasswordData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordData", reflect.TypeOf((*MockEC2API)(nil).GetPasswordData), arg0)
}

// GetPasswordDataRequest mocks base method.
func (m *MockEC2API) GetPasswordDataRequest(arg0 *ec2.GetPasswordDataInput) (*request.Request, *ec2.GetPasswordDataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPasswordDataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetPasswordDataOutput)
	return ret0, ret1
}

// GetPasswordDataRequest indicates an expected call of GetPasswordDataRequest.
func (mr *MockEC2APIMockRecorder) GetPasswordDataRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetPasswordDataRequest), arg0)
}

// GetPasswordDataWithContext mocks base method.
func (m *MockEC2API) GetPasswordDataWithContext(arg0 context.Context, arg1 *ec2.GetPasswordDataInput, arg2 ...request.Option) (*ec2.GetPasswordDataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPasswordDataWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetPasswordDataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReservedInstancesExchangeQuote mocks base method.
func (m *MockEC2API) GetReservedInstancesExchangeQuote(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuote", arg0)
	ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReservedInstancesExchangeQuote indicates an expected call of GetReservedInstancesExchangeQuote.
func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuote), arg0)
}

// GetReservedInstancesExchangeQuoteRequest mocks base method.
func (m *MockEC2API) GetReservedInstancesExchangeQuoteRequest(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.GetReservedInstancesExchangeQuoteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetReservedInstancesExchangeQuoteOutput)
	return ret0, ret1
}

// GetReservedInstancesExchangeQuoteRequest indicates an expected call of GetReservedInstancesExchangeQuoteRequest.
func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteRequest), arg0)
}

// GetReservedInstancesExchangeQuoteWithContext mocks base method.
func (m *MockEC2API) GetReservedInstancesExchangeQuoteWithContext(arg0 context.Context, arg1 *ec2.GetReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSecurityGroupsForVpc mocks base method.
func (m *MockEC2API) GetSecurityGroupsForVpc(arg0 *ec2.GetSecurityGroupsForVpcInput) (*ec2.GetSecurityGroupsForVpcOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpc", arg0)
	ret0, _ := ret[0].(*ec2.GetSecurityGroupsForVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSecurityGroupsForVpc indicates an expected call of GetSecurityGroupsForVpc.
func (mr *MockEC2APIMockRecorder) GetSecurityGroupsForVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpc", reflect.TypeOf((*MockEC2API)(nil).GetSecurityGroupsForVpc), arg0)
}

// GetSecurityGroupsForVpcPages mocks base method.
func (m *MockEC2API) GetSecurityGroupsForVpcPages(arg0 *ec2.GetSecurityGroupsForVpcInput, arg1 func(*ec2.GetSecurityGroupsForVpcOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetSecurityGroupsForVpcPages indicates an expected call of GetSecurityGroupsForVpcPages.
func (mr *MockEC2APIMockRecorder) GetSecurityGroupsForVpcPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpcPages", reflect.TypeOf((*MockEC2API)(nil).GetSecurityGroupsForVpcPages), arg0, arg1)
}

// GetSecurityGroupsForVpcPagesWithContext mocks base method.
func (m *MockEC2API) GetSecurityGroupsForVpcPagesWithContext(arg0 context.Context, arg1 *ec2.GetSecurityGroupsForVpcInput, arg2 func(*ec2.GetSecurityGroupsForVpcOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetSecurityGroupsForVpcRequest mocks base method.
func (m *MockEC2API) GetSecurityGroupsForVpcRequest(arg0 *ec2.GetSecurityGroupsForVpcInput) (*request.Request, *ec2.GetSecurityGroupsForVpcOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetSecurityGroupsForVpcOutput)
	return ret0, ret1
}

// GetSecurityGroupsForVpcRequest indicates an expected call of GetSecurityGroupsForVpcRequest.
func (mr *MockEC2APIMockRecorder) GetSecurityGroupsForVpcRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpcRequest", reflect.TypeOf((*MockEC2API)(nil).GetSecurityGroupsForVpcRequest), arg0)
}

// GetSecurityGroupsForVpcWithContext mocks base method.
func (m *MockEC2API) GetSecurityGroupsForVpcWithContext(arg0 context.Context, arg1 *ec2.GetSecurityGroupsForVpcInput, arg2 ...request.Option) (*ec2.GetSecurityGroupsForVpcOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetSecurityGroupsForVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSerialConsoleAccessStatus mocks base method.
func (m *MockEC2API) GetSerialConsoleAccessStatus(arg0 *ec2.GetSerialConsoleAccessStatusInput) (*ec2.GetSerialConsoleAccessStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatus", arg0)
	ret0, _ := ret[0].(*ec2.GetSerialConsoleAccessStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSerialConsoleAccessStatus indicates an expected call of GetSerialConsoleAccessStatus.
func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatus", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatus), arg0)
}

// GetSerialConsoleAccessStatusRequest mocks base method.
func (m *MockEC2API) GetSerialConsoleAccessStatusRequest(arg0 *ec2.GetSerialConsoleAccessStatusInput) (*request.Request, *ec2.GetSerialConsoleAccessStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetSerialConsoleAccessStatusOutput)
	return ret0, ret1
}

// GetSerialConsoleAccessStatusRequest indicates an expected call of GetSerialConsoleAccessStatusRequest.
func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatusRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatusRequest", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatusRequest), arg0)
}

// GetSerialConsoleAccessStatusWithContext mocks base method.
func (m *MockEC2API) GetSerialConsoleAccessStatusWithContext(arg0 context.Context, arg1 *ec2.GetSerialConsoleAccessStatusInput, arg2 ...request.Option) (*ec2.GetSerialConsoleAccessStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatusWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetSerialConsoleAccessStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSnapshotBlockPublicAccessState mocks base method.
func (m *MockEC2API) GetSnapshotBlockPublicAccessState(arg0 *ec2.GetSnapshotBlockPublicAccessStateInput) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessState", arg0)
	ret0, _ := ret[0].(*ec2.GetSnapshotBlockPublicAccessStateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSnapshotBlockPublicAccessState indicates an expected call of GetSnapshotBlockPublicAccessState.
func (mr *MockEC2APIMockRecorder) GetSnapshotBlockPublicAccessState(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotBlockPublicAccessState", reflect.TypeOf((*MockEC2API)(nil).GetSnapshotBlockPublicAccessState), arg0)
}

// GetSnapshotBlockPublicAccessStateRequest mocks base method.
func (m *MockEC2API) GetSnapshotBlockPublicAccessStateRequest(arg0 *ec2.GetSnapshotBlockPublicAccessStateInput) (*request.Request, *ec2.GetSnapshotBlockPublicAccessStateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessStateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetSnapshotBlockPublicAccessStateOutput)
	return ret0, ret1
}

// GetSnapshotBlockPublicAccessStateRequest indicates an expected call of GetSnapshotBlockPublicAccessStateRequest.
func (mr *MockEC2APIMockRecorder) GetSnapshotBlockPublicAccessStateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotBlockPublicAccessStateRequest", reflect.TypeOf((*MockEC2API)(nil).GetSnapshotBlockPublicAccessStateRequest), arg0)
}

// GetSnapshotBlockPublicAccessStateWithContext mocks base method.
func (m *MockEC2API) GetSnapshotBlockPublicAccessStateWithContext(arg0 context.Context, arg1 *ec2.GetSnapshotBlockPublicAccessStateInput, arg2 ...request.Option) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessStateWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetSnapshotBlockPublicAccessStateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSpotPlacementScores mocks base method.
func (m *MockEC2API) GetSpotPlacementScores(arg0 *ec2.GetSpotPlacementScoresInput) (*ec2.GetSpotPlacementScoresOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSpotPlacementScores", arg0)
	ret0, _ := ret[0].(*ec2.GetSpotPlacementScoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSpotPlacementScores indicates an expected call of GetSpotPlacementScores.
func (mr *MockEC2APIMockRecorder) GetSpotPlacementScores(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScores", reflect.TypeOf((*MockEC2API)(nil).GetSpotPlacementScores), arg0)
}

// GetSpotPlacementScoresPages mocks base method.
func (m *MockEC2API) GetSpotPlacementScoresPages(arg0 *ec2.GetSpotPlacementScoresInput, arg1 func(*ec2.GetSpotPlacementScoresOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSpotPlacementScoresPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetSpotPlacementScoresPages indicates an expected call of GetSpotPlacementScoresPages.
func (mr *MockEC2APIMockRecorder) GetSpotPlacementScoresPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScoresPages", reflect.TypeOf((*MockEC2API)(nil).GetSpotPlacementScoresPages), arg0, arg1)
}

// GetSpotPlacementScoresPagesWithContext mocks base method.
func (m *MockEC2API) GetSpotPlacementScoresPagesWithContext(arg0 context.Context, arg1 *ec2.GetSpotPlacementScoresInput, arg2 func(*ec2.GetSpotPlacementScoresOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSpotPlacementScoresPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetSpotPlacementScoresRequest mocks base method.
func (m *MockEC2API) GetSpotPlacementScoresRequest(arg0 *ec2.GetSpotPlacementScoresInput) (*request.Request, *ec2.GetSpotPlacementScoresOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSpotPlacementScoresRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetSpotPlacementScoresOutput)
	return ret0, ret1
}

// GetSpotPlacementScoresRequest indicates an expected call of GetSpotPlacementScoresRequest.
func (mr *MockEC2APIMockRecorder) GetSpotPlacementScoresRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScoresRequest", reflect.TypeOf((*MockEC2API)(nil).GetSpotPlacementScoresRequest), arg0)
}

// GetSpotPlacementScoresWithContext mocks base method.
func (m *MockEC2API) GetSpotPlacementScoresWithContext(arg0 context.Context, arg1 *ec2.GetSpotPlacementScoresInput, arg2 ...request.Option) (*ec2.GetSpotPlacementScoresOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSpotPlacementScoresWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetSpotPlacementScoresOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSubnetCidrReservations mocks base method.
func (m *MockEC2API) GetSubnetCidrReservations(arg0 *ec2.GetSubnetCidrReservationsInput) (*ec2.GetSubnetCidrReservationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubnetCidrReservations", arg0)
	ret0, _ := ret[0].(*ec2.GetSubnetCidrReservationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubnetCidrReservations indicates an expected call of GetSubnetCidrReservations.
func (mr *MockEC2APIMockRecorder) GetSubnetCidrReservations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetCidrReservations", reflect.TypeOf((*MockEC2API)(nil).GetSubnetCidrReservations), arg0)
}

// GetSubnetCidrReservationsRequest mocks base method.
func (m *MockEC2API) GetSubnetCidrReservationsRequest(arg0 *ec2.GetSubnetCidrReservationsInput) (*request.Request, *ec2.GetSubnetCidrReservationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubnetCidrReservationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetSubnetCidrReservationsOutput)
	return ret0, ret1
}

// GetSubnetCidrReservationsRequest indicates an expected call of GetSubnetCidrReservationsRequest.
func (mr *MockEC2APIMockRecorder) GetSubnetCidrReservationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetCidrReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetSubnetCidrReservationsRequest), arg0)
}

// GetSubnetCidrReservationsWithContext mocks base method.
func (m *MockEC2API) GetSubnetCidrReservationsWithContext(arg0 context.Context, arg1 *ec2.GetSubnetCidrReservationsInput, arg2 ...request.Option) (*ec2.GetSubnetCidrReservationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSubnetCidrReservationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetSubnetCidrReservationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransitGatewayAttachmentPropagations mocks base method.
func (m *MockEC2API) GetTransitGatewayAttachmentPropagations(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagations", arg0)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransitGatewayAttachmentPropagations indicates an expected call of GetTransitGatewayAttachmentPropagations.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagations), arg0)
}

// GetTransitGatewayAttachmentPropagationsPages mocks base method.
func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPages(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg1 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetTransitGatewayAttachmentPropagationsPages indicates an expected call of GetTransitGatewayAttachmentPropagationsPages.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPages), arg0, arg1)
}

// GetTransitGatewayAttachmentPropagationsPagesWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetTransitGatewayAttachmentPropagationsRequest mocks base method.
func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsRequest(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*request.Request, *ec2.GetTransitGatewayAttachmentPropagationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
	return ret0, ret1
}

// GetTransitGatewayAttachmentPropagationsRequest indicates an expected call of GetTransitGatewayAttachmentPropagationsRequest.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsRequest), arg0)
}

// GetTransitGatewayAttachmentPropagationsWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransitGatewayMulticastDomainAssociations mocks base method.
func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociations(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociations", arg0)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransitGatewayMulticastDomainAssociations indicates an expected call of GetTransitGatewayMulticastDomainAssociations.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociations), arg0)
}

// GetTransitGatewayMulticastDomainAssociationsPages mocks base method.
func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsPages(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg1 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetTransitGatewayMulticastDomainAssociationsPages indicates an expected call of GetTransitGatewayMulticastDomainAssociationsPages.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsPages), arg0, arg1)
}

// GetTransitGatewayMulticastDomainAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg2 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetTransitGatewayMulticastDomainAssociationsRequest mocks base method.
func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.GetTransitGatewayMulticastDomainAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
	return ret0, ret1
}

// GetTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of GetTransitGatewayMulticastDomainAssociationsRequest.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsRequest), arg0)
}

// GetTransitGatewayMulticastDomainAssociationsWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransitGatewayPolicyTableAssociations mocks base method.
func (m *MockEC2API) GetTransitGatewayPolicyTableAssociations(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociations", arg0)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransitGatewayPolicyTableAssociations indicates an expected call of GetTransitGatewayPolicyTableAssociations.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableAssociations), arg0)
}

// GetTransitGatewayPolicyTableAssociationsPages mocks base method.
func (m *MockEC2API) GetTransitGatewayPolicyTableAssociationsPages(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg1 func(*ec2.GetTransitGatewayPolicyTableAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetTransitGatewayPolicyTableAssociationsPages indicates an expected call of GetTransitGatewayPolicyTableAssociationsPages.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableAssociationsPages), arg0, arg1)
}

// GetTransitGatewayPolicyTableAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayPolicyTableAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg2 func(*ec2.GetTransitGatewayPolicyTableAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetTransitGatewayPolicyTableAssociationsRequest mocks base method.
func (m *MockEC2API) GetTransitGatewayPolicyTableAssociationsRequest(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayPolicyTableAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput)
	return ret0, ret1
}

// GetTransitGatewayPolicyTableAssociationsRequest indicates an expected call of GetTransitGatewayPolicyTableAssociationsRequest.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableAssociationsRequest), arg0)
}

// GetTransitGatewayPolicyTableAssociationsWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayPolicyTableAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransitGatewayPolicyTableEntries mocks base method.
func (m *MockEC2API) GetTransitGatewayPolicyTableEntries(arg0 *ec2.GetTransitGatewayPolicyTableEntriesInput) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntries", arg0)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableEntriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransitGatewayPolicyTableEntries indicates an expected call of GetTransitGatewayPolicyTableEntries.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableEntries(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableEntries", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableEntries), arg0)
}

// GetTransitGatewayPolicyTableEntriesRequest mocks base method.
func (m *MockEC2API) GetTransitGatewayPolicyTableEntriesRequest(arg0 *ec2.GetTransitGatewayPolicyTableEntriesInput) (*request.Request, *ec2.GetTransitGatewayPolicyTableEntriesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntriesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetTransitGatewayPolicyTableEntriesOutput)
	return ret0, ret1
}

// GetTransitGatewayPolicyTableEntriesRequest indicates an expected call of GetTransitGatewayPolicyTableEntriesRequest.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayPolicyTableEntriesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableEntriesRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPolicyTableEntriesRequest), arg0)
}

// GetTransitGatewayPolicyTableEntriesWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayPolicyTableEntriesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableEntriesInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntriesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableEntriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransitGatewayPrefixListReferences mocks base method.
func (m *MockEC2API) GetTransitGatewayPrefixListReferences(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferences", arg0)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayPrefixListReferencesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransitGatewayPrefixListReferences indicates an expected call of GetTransitGatewayPrefixListReferences.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferences(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferences", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferences), arg0)
}

// GetTransitGatewayPrefixListReferencesPages mocks base method.
func (m *MockEC2API) GetTransitGatewayPrefixListReferencesPages(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput, arg1 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetTransitGatewayPrefixListReferencesPages indicates an expected call of GetTransitGatewayPrefixListReferencesPages.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesPages), arg0, arg1)
}

// GetTransitGatewayPrefixListReferencesPagesWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayPrefixListReferencesPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPrefixListReferencesInput, arg2 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetTransitGatewayPrefixListReferencesRequest mocks base method.
func (m *MockEC2API) GetTransitGatewayPrefixListReferencesRequest(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*request.Request, *ec2.GetTransitGatewayPrefixListReferencesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetTransitGatewayPrefixListReferencesOutput)
	return ret0, ret1
}

// GetTransitGatewayPrefixListReferencesRequest indicates an expected call of GetTransitGatewayPrefixListReferencesRequest.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesRequest), arg0)
}

// GetTransitGatewayPrefixListReferencesWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayPrefixListReferencesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPrefixListReferencesInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayPrefixListReferencesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransitGatewayRouteTableAssociations mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTableAssociations(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociations", arg0)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransitGatewayRouteTableAssociations indicates an expected call of GetTransitGatewayRouteTableAssociations.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociations), arg0)
}

// GetTransitGatewayRouteTableAssociationsPages mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPages(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg1 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetTransitGatewayRouteTableAssociationsPages indicates an expected call of GetTransitGatewayRouteTableAssociationsPages.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPages), arg0, arg1)
}

// GetTransitGatewayRouteTableAssociationsPagesWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetTransitGatewayRouteTableAssociationsRequest mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsRequest(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTableAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
	return ret0, ret1
}

// GetTransitGatewayRouteTableAssociationsRequest indicates an expected call of GetTransitGatewayRouteTableAssociationsRequest.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsRequest), arg0)
}

// GetTransitGatewayRouteTableAssociationsWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransitGatewayRouteTablePropagations mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTablePropagations(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagations", arg0)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransitGatewayRouteTablePropagations indicates an expected call of GetTransitGatewayRouteTablePropagations.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagations), arg0)
}

// GetTransitGatewayRouteTablePropagationsPages mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPages(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg1 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetTransitGatewayRouteTablePropagationsPages indicates an expected call of GetTransitGatewayRouteTablePropagationsPages.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPages), arg0, arg1)
}

// GetTransitGatewayRouteTablePropagationsPagesWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetTransitGatewayRouteTablePropagationsRequest mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsRequest(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTablePropagationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
	return ret0, ret1
}

// GetTransitGatewayRouteTablePropagationsRequest indicates an expected call of GetTransitGatewayRouteTablePropagationsRequest.
func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsRequest), arg0)
}

// GetTransitGatewayRouteTablePropagationsWithContext mocks base method.
func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVerifiedAccessEndpointPolicy mocks base method.
func (m *MockEC2API) GetVerifiedAccessEndpointPolicy(arg0 *ec2.GetVerifiedAccessEndpointPolicyInput) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicy", arg0)
	ret0, _ := ret[0].(*ec2.GetVerifiedAccessEndpointPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVerifiedAccessEndpointPolicy indicates an expected call of GetVerifiedAccessEndpointPolicy.
func (mr *MockEC2APIMockRecorder) GetVerifiedAccessEndpointPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessEndpointPolicy", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessEndpointPolicy), arg0)
}

// GetVerifiedAccessEndpointPolicyRequest mocks base method.
func (m *MockEC2API) GetVerifiedAccessEndpointPolicyRequest(arg0 *ec2.GetVerifiedAccessEndpointPolicyInput) (*request.Request, *ec2.GetVerifiedAccessEndpointPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetVerifiedAccessEndpointPolicyOutput)
	return ret0, ret1
}

// GetVerifiedAccessEndpointPolicyRequest indicates an expected call of GetVerifiedAccessEndpointPolicyRequest.
func (mr *MockEC2APIMockRecorder) GetVerifiedAccessEndpointPolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessEndpointPolicyRequest", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessEndpointPolicyRequest), arg0)
}

// GetVerifiedAccessEndpointPolicyWithContext mocks base method.
func (m *MockEC2API) GetVerifiedAccessEndpointPolicyWithContext(arg0 context.Context, arg1 *ec2.GetVerifiedAccessEndpointPolicyInput, arg2 ...request.Option) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetVerifiedAccessEndpointPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVerifiedAccessGroupPolicy mocks base method.
func (m *MockEC2API) GetVerifiedAccessGroupPolicy(arg0 *ec2.GetVerifiedAccessGroupPolicyInput) (*ec2.GetVerifiedAccessGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicy", arg0)
	ret0, _ := ret[0].(*ec2.GetVerifiedAccessGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVerifiedAccessGroupPolicy indicates an expected call of GetVerifiedAccessGroupPolicy.
func (mr *MockEC2APIMockRecorder) GetVerifiedAccessGroupPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessGroupPolicy", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessGroupPolicy), arg0)
}

// GetVerifiedAccessGroupPolicyRequest mocks base method.
func (m *MockEC2API) GetVerifiedAccessGroupPolicyRequest(arg0 *ec2.GetVerifiedAccessGroupPolicyInput) (*request.Request, *ec2.GetVerifiedAccessGroupPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetVerifiedAccessGroupPolicyOutput)
	return ret0, ret1
}

// GetVerifiedAccessGroupPolicyRequest indicates an expected call of GetVerifiedAccessGroupPolicyRequest.
func (mr *MockEC2APIMockRecorder) GetVerifiedAccessGroupPolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessGroupPolicyRequest", reflect.TypeOf((*MockEC2API)(nil).GetVerifiedAccessGroupPolicyRequest), arg0)
}

// GetVerifiedAccessGroupPolicyWithContext mocks base method.
func (m *MockEC2API) GetVerifiedAccessGroupPolicyWithContext(arg0 context.Context, arg1 *ec2.GetVerifiedAccessGroupPolicyInput, arg2 ...request.Option) (*ec2.GetVerifiedAccessGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetVerifiedAccessGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVpnConnectionDeviceSampleConfiguration mocks base method.
func (m *MockEC2API) GetVpnConnectionDeviceSampleConfiguration(arg0 *ec2.GetVpnConnectionDeviceSampleConfigurationInput) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfiguration", arg0)
	ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVpnConnectionDeviceSampleConfiguration indicates an expected call of GetVpnConnectionDeviceSampleConfiguration.
func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceSampleConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceSampleConfiguration", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceSampleConfiguration), arg0)
}

// GetVpnConnectionDeviceSampleConfigurationRequest mocks base method.
func (m *MockEC2API) GetVpnConnectionDeviceSampleConfigurationRequest(arg0 *ec2.GetVpnConnectionDeviceSampleConfigurationInput) (*request.Request, *ec2.GetVpnConnectionDeviceSampleConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput)
	return ret0, ret1
}

// GetVpnConnectionDeviceSampleConfigurationRequest indicates an expected call of GetVpnConnectionDeviceSampleConfigurationRequest.
func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceSampleConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceSampleConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceSampleConfigurationRequest), arg0)
}

// GetVpnConnectionDeviceSampleConfigurationWithContext mocks base method.
func (m *MockEC2API) GetVpnConnectionDeviceSampleConfigurationWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceSampleConfigurationInput, arg2 ...request.Option) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVpnConnectionDeviceTypes mocks base method.
func (m *MockEC2API) GetVpnConnectionDeviceTypes(arg0 *ec2.GetVpnConnectionDeviceTypesInput) (*ec2.GetVpnConnectionDeviceTypesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypes", arg0)
	ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceTypesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVpnConnectionDeviceTypes indicates an expected call of GetVpnConnectionDeviceTypes.
func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypes", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypes), arg0)
}

// GetVpnConnectionDeviceTypesPages mocks base method.
func (m *MockEC2API) GetVpnConnectionDeviceTypesPages(arg0 *ec2.GetVpnConnectionDeviceTypesInput, arg1 func(*ec2.GetVpnConnectionDeviceTypesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetVpnConnectionDeviceTypesPages indicates an expected call of GetVpnConnectionDeviceTypesPages.
func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypesPages", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypesPages), arg0, arg1)
}

// GetVpnConnectionDeviceTypesPagesWithContext mocks base method.
func (m *MockEC2API) GetVpnConnectionDeviceTypesPagesWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceTypesInput, arg2 func(*ec2.GetVpnConnectionDeviceTypesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetVpnConnectionDeviceTypesRequest mocks base method.
func (m *MockEC2API) GetVpnConnectionDeviceTypesRequest(arg0 *ec2.GetVpnConnectionDeviceTypesInput) (*request.Request, *ec2.GetVpnConnectionDeviceTypesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetVpnConnectionDeviceTypesOutput)
	return ret0, ret1
}

// GetVpnConnectionDeviceTypesRequest indicates an expected call of GetVpnConnectionDeviceTypesRequest.
func (mr *MockEC2APIMockRecorder) GetVpnConnectionDeviceTypesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypesRequest", reflect.TypeOf((*MockEC2API)(nil).GetVpnConnectionDeviceTypesRequest), arg0)
}

// GetVpnConnectionDeviceTypesWithContext mocks base method.
func (m *MockEC2API) GetVpnConnectionDeviceTypesWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceTypesInput, arg2 ...request.Option) (*ec2.GetVpnConnectionDeviceTypesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceTypesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVpnTunnelReplacementStatus mocks base method.
func (m *MockEC2API) GetVpnTunnelReplacementStatus(arg0 *ec2.GetVpnTunnelReplacementStatusInput) (*ec2.GetVpnTunnelReplacementStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatus", arg0)
	ret0, _ := ret[0].(*ec2.GetVpnTunnelReplacementStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVpnTunnelReplacementStatus indicates an expected call of GetVpnTunnelReplacementStatus.
func (mr *MockEC2APIMockRecorder) GetVpnTunnelReplacementStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnTunnelReplacementStatus", reflect.TypeOf((*MockEC2API)(nil).GetVpnTunnelReplacementStatus), arg0)
}

// GetVpnTunnelReplacementStatusRequest mocks base method.
func (m *MockEC2API) GetVpnTunnelReplacementStatusRequest(arg0 *ec2.GetVpnTunnelReplacementStatusInput) (*request.Request, *ec2.GetVpnTunnelReplacementStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.GetVpnTunnelReplacementStatusOutput)
	return ret0, ret1
}

// GetVpnTunnelReplacementStatusRequest indicates an expected call of GetVpnTunnelReplacementStatusRequest.
func (mr *MockEC2APIMockRecorder) GetVpnTunnelReplacementStatusRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnTunnelReplacementStatusRequest", reflect.TypeOf((*MockEC2API)(nil).GetVpnTunnelReplacementStatusRequest), arg0)
}

// GetVpnTunnelReplacementStatusWithContext mocks base method.
func (m *MockEC2API) GetVpnTunnelReplacementStatusWithContext(arg0 context.Context, arg1 *ec2.GetVpnTunnelReplacementStatusInput, arg2 ...request.Option) (*ec2.GetVpnTunnelReplacementStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVpnTunnelReplacementStatusWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.GetVpnTunnelReplacementStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportClientVpnClientCertificateRevocationList mocks base method.
func (m *MockEC2API) ImportClientVpnClientCertificateRevocationList(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationList", arg0)
	ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportClientVpnClientCertificateRevocationList indicates an expected call of ImportClientVpnClientCertificateRevocationList.
func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationList), arg0)
}

// ImportClientVpnClientCertificateRevocationListRequest mocks base method.
func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ImportClientVpnClientCertificateRevocationListOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
	return ret0, ret1
}

// ImportClientVpnClientCertificateRevocationListRequest indicates an expected call of ImportClientVpnClientCertificateRevocationListRequest.
func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListRequest), arg0)
}

// ImportClientVpnClientCertificateRevocationListWithContext mocks base method.
func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListWithContext(arg0 context.Context, arg1 *ec2.ImportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportImage mocks base method.
func (m *MockEC2API) ImportImage(arg0 *ec2.ImportImageInput) (*ec2.ImportImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportImage", arg0)
	ret0, _ := ret[0].(*ec2.ImportImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportImage indicates an expected call of ImportImage.
func (mr *MockEC2APIMockRecorder) ImportImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImage", reflect.TypeOf((*MockEC2API)(nil).ImportImage), arg0)
}

// ImportImageRequest mocks base method.
func (m *MockEC2API) ImportImageRequest(arg0 *ec2.ImportImageInput) (*request.Request, *ec2.ImportImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ImportImageOutput)
	return ret0, ret1
}

// ImportImageRequest indicates an expected call of ImportImageRequest.
func (mr *MockEC2APIMockRecorder) ImportImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ImportImageRequest), arg0)
}

// ImportImageWithContext mocks base method.
func (m *MockEC2API) ImportImageWithContext(arg0 context.Context, arg1 *ec2.ImportImageInput, arg2 ...request.Option) (*ec2.ImportImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ImportImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportInstance mocks base method.
func (m *MockEC2API) ImportInstance(arg0 *ec2.ImportInstanceInput) (*ec2.ImportInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportInstance", arg0)
	ret0, _ := ret[0].(*ec2.ImportInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportInstance indicates an expected call of ImportInstance.
func (mr *MockEC2APIMockRecorder) ImportInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstance", reflect.TypeOf((*MockEC2API)(nil).ImportInstance), arg0)
}

// ImportInstanceRequest mocks base method.
func (m *MockEC2API) ImportInstanceRequest(arg0 *ec2.ImportInstanceInput) (*request.Request, *ec2.ImportInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ImportInstanceOutput)
	return ret0, ret1
}

// ImportInstanceRequest indicates an expected call of ImportInstanceRequest.
func (mr *MockEC2APIMockRecorder) ImportInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ImportInstanceRequest), arg0)
}

// ImportInstanceWithContext mocks base method.
func (m *MockEC2API) ImportInstanceWithContext(arg0 context.Context, arg1 *ec2.ImportInstanceInput, arg2 ...request.Option) (*ec2.ImportInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ImportInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportKeyPair mocks base method.
func (m *MockEC2API) ImportKeyPair(arg0 *ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportKeyPair", arg0)
	ret0, _ := ret[0].(*ec2.ImportKeyPairOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportKeyPair indicates an expected call of ImportKeyPair.
func (mr *MockEC2APIMockRecorder) ImportKeyPair(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPair", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPair), arg0)
}

// ImportKeyPairRequest mocks base method.
func (m *MockEC2API) ImportKeyPairRequest(arg0 *ec2.ImportKeyPairInput) (*request.Request, *ec2.ImportKeyPairOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportKeyPairRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ImportKeyPairOutput)
	return ret0, ret1
}

// ImportKeyPairRequest indicates an expected call of ImportKeyPairRequest.
func (mr *MockEC2APIMockRecorder) ImportKeyPairRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPairRequest), arg0)
}

// ImportKeyPairWithContext mocks base method.
func (m *MockEC2API) ImportKeyPairWithContext(arg0 context.Context, arg1 *ec2.ImportKeyPairInput, arg2 ...request.Option) (*ec2.ImportKeyPairOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportKeyPairWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ImportKeyPairOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportSnapshot mocks base method.
func (m *MockEC2API) ImportSnapshot(arg0 *ec2.ImportSnapshotInput) (*ec2.ImportSnapshotOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportSnapshot", arg0)
	ret0, _ := ret[0].(*ec2.ImportSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportSnapshot indicates an expected call of ImportSnapshot.
func (mr *MockEC2APIMockRecorder) ImportSnapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshot", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshot), arg0)
}

// ImportSnapshotRequest mocks base method.
func (m *MockEC2API) ImportSnapshotRequest(arg0 *ec2.ImportSnapshotInput) (*request.Request, *ec2.ImportSnapshotOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportSnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ImportSnapshotOutput)
	return ret0, ret1
}

// ImportSnapshotRequest indicates an expected call of ImportSnapshotRequest.
func (mr *MockEC2APIMockRecorder) ImportSnapshotRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshotRequest), arg0)
}

// ImportSnapshotWithContext mocks base method.
func (m *MockEC2API) ImportSnapshotWithContext(arg0 context.Context, arg1 *ec2.ImportSnapshotInput, arg2 ...request.Option) (*ec2.ImportSnapshotOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportSnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ImportSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportVolume mocks base method.
func (m *MockEC2API) ImportVolume(arg0 *ec2.ImportVolumeInput) (*ec2.ImportVolumeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportVolume", arg0)
	ret0, _ := ret[0].(*ec2.ImportVolumeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportVolume indicates an expected call of ImportVolume.
func (mr *MockEC2APIMockRecorder) ImportVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolume", reflect.TypeOf((*MockEC2API)(nil).ImportVolume), arg0)
}

// ImportVolumeRequest mocks base method.
func (m *MockEC2API) ImportVolumeRequest(arg0 *ec2.ImportVolumeInput) (*request.Request, *ec2.ImportVolumeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportVolumeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ImportVolumeOutput)
	return ret0, ret1
}

// ImportVolumeRequest indicates an expected call of ImportVolumeRequest.
func (mr *MockEC2APIMockRecorder) ImportVolumeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeRequest), arg0)
}

// ImportVolumeWithContext mocks base method.
func (m *MockEC2API) ImportVolumeWithContext(arg0 context.Context, arg1 *ec2.ImportVolumeInput, arg2 ...request.Option) (*ec2.ImportVolumeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportVolumeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ImportVolumeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListImagesInRecycleBin mocks base method.
func (m *MockEC2API) ListImagesInRecycleBin(arg0 *ec2.ListImagesInRecycleBinInput) (*ec2.ListImagesInRecycleBinOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImagesInRecycleBin", arg0)
	ret0, _ := ret[0].(*ec2.ListImagesInRecycleBinOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListImagesInRecycleBin indicates an expected call of ListImagesInRecycleBin.
func (mr *MockEC2APIMockRecorder) ListImagesInRecycleBin(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBin", reflect.TypeOf((*MockEC2API)(nil).ListImagesInRecycleBin), arg0)
}

// ListImagesInRecycleBinPages mocks base method.
func (m *MockEC2API) ListImagesInRecycleBinPages(arg0 *ec2.ListImagesInRecycleBinInput, arg1 func(*ec2.ListImagesInRecycleBinOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImagesInRecycleBinPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListImagesInRecycleBinPages indicates an expected call of ListImagesInRecycleBinPages.
func (mr *MockEC2APIMockRecorder) ListImagesInRecycleBinPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBinPages", reflect.TypeOf((*MockEC2API)(nil).ListImagesInRecycleBinPages), arg0, arg1)
}

// ListImagesInRecycleBinPagesWithContext mocks base method.
func (m *MockEC2API) ListImagesInRecycleBinPagesWithContext(arg0 context.Context, arg1 *ec2.ListImagesInRecycleBinInput, arg2 func(*ec2.ListImagesInRecycleBinOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListImagesInRecycleBinPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListImagesInRecycleBinRequest mocks base method.
func (m *MockEC2API) ListImagesInRecycleBinRequest(arg0 *ec2.ListImagesInRecycleBinInput) (*request.Request, *ec2.ListImagesInRecycleBinOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImagesInRecycleBinRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ListImagesInRecycleBinOutput)
	return ret0, ret1
}

// ListImagesInRecycleBinRequest indicates an expected call of ListImagesInRecycleBinRequest.
func (mr *MockEC2APIMockRecorder) ListImagesInRecycleBinRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBinRequest", reflect.TypeOf((*MockEC2API)(nil).ListImagesInRecycleBinRequest), arg0)
}

// ListImagesInRecycleBinWithContext mocks base method.
func (m *MockEC2API) ListImagesInRecycleBinWithContext(arg0 context.Context, arg1 *ec2.ListImagesInRecycleBinInput, arg2 ...request.Option) (*ec2.ListImagesInRecycleBinOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListImagesInRecycleBinWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ListImagesInRecycleBinOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSnapshotsInRecycleBin mocks base method.
func (m *MockEC2API) ListSnapshotsInRecycleBin(arg0 *ec2.ListSnapshotsInRecycleBinInput) (*ec2.ListSnapshotsInRecycleBinOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBin", arg0)
	ret0, _ := ret[0].(*ec2.ListSnapshotsInRecycleBinOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSnapshotsInRecycleBin indicates an expected call of ListSnapshotsInRecycleBin.
func (mr *MockEC2APIMockRecorder) ListSnapshotsInRecycleBin(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBin", reflect.TypeOf((*MockEC2API)(nil).ListSnapshotsInRecycleBin), arg0)
}

// ListSnapshotsInRecycleBinPages mocks base method.
func (m *MockEC2API) ListSnapshotsInRecycleBinPages(arg0 *ec2.ListSnapshotsInRecycleBinInput, arg1 func(*ec2.ListSnapshotsInRecycleBinOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSnapshotsInRecycleBinPages indicates an expected call of ListSnapshotsInRecycleBinPages.
func (mr *MockEC2APIMockRecorder) ListSnapshotsInRecycleBinPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBinPages", reflect.TypeOf((*MockEC2API)(nil).ListSnapshotsInRecycleBinPages), arg0, arg1)
}

// ListSnapshotsInRecycleBinPagesWithContext mocks base method.
func (m *MockEC2API) ListSnapshotsInRecycleBinPagesWithContext(arg0 context.Context, arg1 *ec2.ListSnapshotsInRecycleBinInput, arg2 func(*ec2.ListSnapshotsInRecycleBinOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListSnapshotsInRecycleBinRequest mocks base method.
func (m *MockEC2API) ListSnapshotsInRecycleBinRequest(arg0 *ec2.ListSnapshotsInRecycleBinInput) (*request.Request, *ec2.ListSnapshotsInRecycleBinOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ListSnapshotsInRecycleBinOutput)
	return ret0, ret1
}

// ListSnapshotsInRecycleBinRequest indicates an expected call of ListSnapshotsInRecycleBinRequest.
func (mr *MockEC2APIMockRecorder) ListSnapshotsInRecycleBinRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBinRequest", reflect.TypeOf((*MockEC2API)(nil).ListSnapshotsInRecycleBinRequest), arg0)
}

// ListSnapshotsInRecycleBinWithContext mocks base method.
func (m *MockEC2API) ListSnapshotsInRecycleBinWithContext(arg0 context.Context, arg1 *ec2.ListSnapshotsInRecycleBinInput, arg2 ...request.Option) (*ec2.ListSnapshotsInRecycleBinOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ListSnapshotsInRecycleBinOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LockSnapshot mocks base method.
func (m *MockEC2API) LockSnapshot(arg0 *ec2.LockSnapshotInput) (*ec2.LockSnapshotOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockSnapshot", arg0)
	ret0, _ := ret[0].(*ec2.LockSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LockSnapshot indicates an expected call of LockSnapshot.
func (mr *MockEC2APIMockRecorder) LockSnapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockSnapshot", reflect.TypeOf((*MockEC2API)(nil).LockSnapshot), arg0)
}

// LockSnapshotRequest mocks base method.
func (m *MockEC2API) LockSnapshotRequest(arg0 *ec2.LockSnapshotInput) (*request.Request, *ec2.LockSnapshotOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockSnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.LockSnapshotOutput)
	return ret0, ret1
}

// LockSnapshotRequest indicates an expected call of LockSnapshotRequest.
func (mr *MockEC2APIMockRecorder) LockSnapshotRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).LockSnapshotRequest), arg0)
}

// LockSnapshotWithContext mocks base method.
func (m *MockEC2API) LockSnapshotWithContext(arg0 context.Context, arg1 *ec2.LockSnapshotInput, arg2 ...request.Option) (*ec2.LockSnapshotOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LockSnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.LockSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyAddressAttribute mocks base method.
func (m *MockEC2API) ModifyAddressAttribute(arg0 *ec2.ModifyAddressAttributeInput) (*ec2.ModifyAddressAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyAddressAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifyAddressAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyAddressAttribute indicates an expected call of ModifyAddressAttribute.
func (mr *MockEC2APIMockRecorder) ModifyAddressAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAddressAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyAddressAttribute), arg0)
}

// ModifyAddressAttributeRequest mocks base method.
func (m *MockEC2API) ModifyAddressAttributeRequest(arg0 *ec2.ModifyAddressAttributeInput) (*request.Request, *ec2.ModifyAddressAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyAddressAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyAddressAttributeOutput)
	return ret0, ret1
}

// ModifyAddressAttributeRequest indicates an expected call of ModifyAddressAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifyAddressAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAddressAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyAddressAttributeRequest), arg0)
}

// ModifyAddressAttributeWithContext mocks base method.
func (m *MockEC2API) ModifyAddressAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyAddressAttributeInput, arg2 ...request.Option) (*ec2.ModifyAddressAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyAddressAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyAddressAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyAvailabilityZoneGroup mocks base method.
func (m *MockEC2API) ModifyAvailabilityZoneGroup(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*ec2.ModifyAvailabilityZoneGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroup", arg0)
	ret0, _ := ret[0].(*ec2.ModifyAvailabilityZoneGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyAvailabilityZoneGroup indicates an expected call of ModifyAvailabilityZoneGroup.
func (mr *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroup", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroup), arg0)
}

// ModifyAvailabilityZoneGroupRequest mocks base method.
func (m *MockEC2API) ModifyAvailabilityZoneGroupRequest(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*request.Request, *ec2.ModifyAvailabilityZoneGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyAvailabilityZoneGroupOutput)
	return ret0, ret1
}

// ModifyAvailabilityZoneGroupRequest indicates an expected call of ModifyAvailabilityZoneGroupRequest.
func (mr *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroupRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroupRequest), arg0)
}

// ModifyAvailabilityZoneGroupWithContext mocks base method.
func (m *MockEC2API) ModifyAvailabilityZoneGroupWithContext(arg0 context.Context, arg1 *ec2.ModifyAvailabilityZoneGroupInput, arg2 ...request.Option) (*ec2.ModifyAvailabilityZoneGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroupWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyAvailabilityZoneGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyCapacityReservation mocks base method.
func (m *MockEC2API) ModifyCapacityReservation(arg0 *ec2.ModifyCapacityReservationInput) (*ec2.ModifyCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyCapacityReservation", arg0)
	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyCapacityReservation indicates an expected call of ModifyCapacityReservation.
func (mr *MockEC2APIMockRecorder) ModifyCapacityReservation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservation), arg0)
}

// ModifyCapacityReservationFleet mocks base method.
func (m *MockEC2API) ModifyCapacityReservationFleet(arg0 *ec2.ModifyCapacityReservationFleetInput) (*ec2.ModifyCapacityReservationFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyCapacityReservationFleet", arg0)
	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyCapacityReservationFleet indicates an expected call of ModifyCapacityReservationFleet.
func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationFleet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationFleet", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationFleet), arg0)
}

// ModifyCapacityReservationFleetRequest mocks base method.
func (m *MockEC2API) ModifyCapacityReservationFleetRequest(arg0 *ec2.ModifyCapacityReservationFleetInput) (*request.Request, *ec2.ModifyCapacityReservationFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyCapacityReservationFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyCapacityReservationFleetOutput)
	return ret0, ret1
}

// ModifyCapacityReservationFleetRequest indicates an expected call of ModifyCapacityReservationFleetRequest.
func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationFleetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationFleetRequest), arg0)
}

// ModifyCapacityReservationFleetWithContext mocks base method.
func (m *MockEC2API) ModifyCapacityReservationFleetWithContext(arg0 context.Context, arg1 *ec2.ModifyCapacityReservationFleetInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationFleetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyCapacityReservationFleetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyCapacityReservationRequest mocks base method.
func (m *MockEC2API) ModifyCapacityReservationRequest(arg0 *ec2.ModifyCapacityReservationInput) (*request.Request, *ec2.ModifyCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyCapacityReservationOutput)
	return ret0, ret1
}

// ModifyCapacityReservationRequest indicates an expected call of ModifyCapacityReservationRequest.
func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationRequest), arg0)
}

// ModifyCapacityReservationWithContext mocks base method.
func (m *MockEC2API) ModifyCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.ModifyCapacityReservationInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyClientVpnEndpoint mocks base method.
func (m *MockEC2API) ModifyClientVpnEndpoint(arg0 *ec2.ModifyClientVpnEndpointInput) (*ec2.ModifyClientVpnEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyClientVpnEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyClientVpnEndpoint indicates an expected call of ModifyClientVpnEndpoint.
func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpoint), arg0)
}

// ModifyClientVpnEndpointRequest mocks base method.
func (m *MockEC2API) ModifyClientVpnEndpointRequest(arg0 *ec2.ModifyClientVpnEndpointInput) (*request.Request, *ec2.ModifyClientVpnEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyClientVpnEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyClientVpnEndpointOutput)
	return ret0, ret1
}

// ModifyClientVpnEndpointRequest indicates an expected call of ModifyClientVpnEndpointRequest.
func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointRequest), arg0)
}

// ModifyClientVpnEndpointWithContext mocks base method.
func (m *MockEC2API) ModifyClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyClientVpnEndpointInput, arg2 ...request.Option) (*ec2.ModifyClientVpnEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyClientVpnEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyDefaultCreditSpecification mocks base method.
func (m *MockEC2API) ModifyDefaultCreditSpecification(arg0 *ec2.ModifyDefaultCreditSpecificationInput) (*ec2.ModifyDefaultCreditSpecificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecification", arg0)
	ret0, _ := ret[0].(*ec2.ModifyDefaultCreditSpecificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyDefaultCreditSpecification indicates an expected call of ModifyDefaultCreditSpecification.
func (mr *MockEC2APIMockRecorder) ModifyDefaultCreditSpecification(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecification), arg0)
}

// ModifyDefaultCreditSpecificationRequest mocks base method.
func (m *MockEC2API) ModifyDefaultCreditSpecificationRequest(arg0 *ec2.ModifyDefaultCreditSpecificationInput) (*request.Request, *ec2.ModifyDefaultCreditSpecificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyDefaultCreditSpecificationOutput)
	return ret0, ret1
}

// ModifyDefaultCreditSpecificationRequest indicates an expected call of ModifyDefaultCreditSpecificationRequest.
func (mr *MockEC2APIMockRecorder) ModifyDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecificationRequest), arg0)
}

// ModifyDefaultCreditSpecificationWithContext mocks base method.
func (m *MockEC2API) ModifyDefaultCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.ModifyDefaultCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyDefaultCreditSpecificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecificationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyDefaultCreditSpecificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyEbsDefaultKmsKeyId mocks base method.
func (m *MockEC2API) ModifyEbsDefaultKmsKeyId(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyId", arg0)
	ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyEbsDefaultKmsKeyId indicates an expected call of ModifyEbsDefaultKmsKeyId.
func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyId), arg0)
}

// ModifyEbsDefaultKmsKeyIdRequest mocks base method.
func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdRequest(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ModifyEbsDefaultKmsKeyIdOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
	return ret0, ret1
}

// ModifyEbsDefaultKmsKeyIdRequest indicates an expected call of ModifyEbsDefaultKmsKeyIdRequest.
func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdRequest), arg0)
}

// ModifyEbsDefaultKmsKeyIdWithContext mocks base method.
func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.ModifyEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyFleet mocks base method.
func (m *MockEC2API) ModifyFleet(arg0 *ec2.ModifyFleetInput) (*ec2.ModifyFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyFleet", arg0)
	ret0, _ := ret[0].(*ec2.ModifyFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyFleet indicates an expected call of ModifyFleet.
func (mr *MockEC2APIMockRecorder) ModifyFleet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleet", reflect.TypeOf((*MockEC2API)(nil).ModifyFleet), arg0)
}

// ModifyFleetRequest mocks base method.
func (m *MockEC2API) ModifyFleetRequest(arg0 *ec2.ModifyFleetInput) (*request.Request, *ec2.ModifyFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyFleetOutput)
	return ret0, ret1
}

// ModifyFleetRequest indicates an expected call of ModifyFleetRequest.
func (mr *MockEC2APIMockRecorder) ModifyFleetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFleetRequest), arg0)
}

// ModifyFleetWithContext mocks base method.
func (m *MockEC2API) ModifyFleetWithContext(arg0 context.Context, arg1 *ec2.ModifyFleetInput, arg2 ...request.Option) (*ec2.ModifyFleetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyFleetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyFpgaImageAttribute mocks base method.
func (m *MockEC2API) ModifyFpgaImageAttribute(arg0 *ec2.ModifyFpgaImageAttributeInput) (*ec2.ModifyFpgaImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyFpgaImageAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyFpgaImageAttribute indicates an expected call of ModifyFpgaImageAttribute.
func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttribute), arg0)
}

// ModifyFpgaImageAttributeRequest mocks base method.
func (m *MockEC2API) ModifyFpgaImageAttributeRequest(arg0 *ec2.ModifyFpgaImageAttributeInput) (*request.Request, *ec2.ModifyFpgaImageAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyFpgaImageAttributeOutput)
	return ret0, ret1
}

// ModifyFpgaImageAttributeRequest indicates an expected call of ModifyFpgaImageAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttributeRequest), arg0)
}

// ModifyFpgaImageAttributeWithContext mocks base method.
func (m *MockEC2API) ModifyFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyFpgaImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyHosts mocks base method.
func (m *MockEC2API) ModifyHosts(arg0 *ec2.ModifyHostsInput) (*ec2.ModifyHostsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyHosts", arg0)
	ret0, _ := ret[0].(*ec2.ModifyHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyHosts indicates an expected call of ModifyHosts.
func (mr *MockEC2APIMockRecorder) ModifyHosts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHosts", reflect.TypeOf((*MockEC2API)(nil).ModifyHosts), arg0)
}

// ModifyHostsRequest mocks base method.
func (m *MockEC2API) ModifyHostsRequest(arg0 *ec2.ModifyHostsInput) (*request.Request, *ec2.ModifyHostsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyHostsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyHostsOutput)
	return ret0, ret1
}

// ModifyHostsRequest indicates an expected call of ModifyHostsRequest.
func (mr *MockEC2APIMockRecorder) ModifyHostsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyHostsRequest), arg0)
}

// ModifyHostsWithContext mocks base method.
func (m *MockEC2API) ModifyHostsWithContext(arg0 context.Context, arg1 *ec2.ModifyHostsInput, arg2 ...request.Option) (*ec2.ModifyHostsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyHostsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyIdFormat mocks base method.
func (m *MockEC2API) ModifyIdFormat(arg0 *ec2.ModifyIdFormatInput) (*ec2.ModifyIdFormatOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIdFormat", arg0)
	ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyIdFormat indicates an expected call of ModifyIdFormat.
func (mr *MockEC2APIMockRecorder) ModifyIdFormat(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormat), arg0)
}

// ModifyIdFormatRequest mocks base method.
func (m *MockEC2API) ModifyIdFormatRequest(arg0 *ec2.ModifyIdFormatInput) (*request.Request, *ec2.ModifyIdFormatOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIdFormatRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyIdFormatOutput)
	return ret0, ret1
}

// ModifyIdFormatRequest indicates an expected call of ModifyIdFormatRequest.
func (mr *MockEC2APIMockRecorder) ModifyIdFormatRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormatRequest), arg0)
}

// ModifyIdFormatWithContext mocks base method.
func (m *MockEC2API) ModifyIdFormatWithContext(arg0 context.Context, arg1 *ec2.ModifyIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdFormatOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyIdFormatWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyIdentityIdFormat mocks base method.
func (m *MockEC2API) ModifyIdentityIdFormat(arg0 *ec2.ModifyIdentityIdFormatInput) (*ec2.ModifyIdentityIdFormatOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIdentityIdFormat", arg0)
	ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyIdentityIdFormat indicates an expected call of ModifyIdentityIdFormat.
func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormat(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormat), arg0)
}

// ModifyIdentityIdFormatRequest mocks base method.
func (m *MockEC2API) ModifyIdentityIdFormatRequest(arg0 *ec2.ModifyIdentityIdFormatInput) (*request.Request, *ec2.ModifyIdentityIdFormatOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIdentityIdFormatRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyIdentityIdFormatOutput)
	return ret0, ret1
}

// ModifyIdentityIdFormatRequest indicates an expected call of ModifyIdentityIdFormatRequest.
func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormatRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormatRequest), arg0)
}

// ModifyIdentityIdFormatWithContext mocks base method.
func (m *MockEC2API) ModifyIdentityIdFormatWithContext(arg0 context.Context, arg1 *ec2.ModifyIdentityIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdentityIdFormatOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyIdentityIdFormatWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyImageAttribute mocks base method.
func (m *MockEC2API) ModifyImageAttribute(arg0 *ec2.ModifyImageAttributeInput) (*ec2.ModifyImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyImageAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyImageAttribute indicates an expected call of ModifyImageAttribute.
func (mr *MockEC2APIMockRecorder) ModifyImageAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttribute), arg0)
}

// ModifyImageAttributeRequest mocks base method.
func (m *MockEC2API) ModifyImageAttributeRequest(arg0 *ec2.ModifyImageAttributeInput) (*request.Request, *ec2.ModifyImageAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyImageAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyImageAttributeOutput)
	return ret0, ret1
}

// ModifyImageAttributeRequest indicates an expected call of ModifyImageAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifyImageAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttributeRequest), arg0)
}

// ModifyImageAttributeWithContext mocks base method.
func (m *MockEC2API) ModifyImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyImageAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstanceAttribute mocks base method.
func (m *MockEC2API) ModifyInstanceAttribute(arg0 *ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceAttribute indicates an expected call of ModifyInstanceAttribute.
func (mr *MockEC2APIMockRecorder) ModifyInstanceAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttribute), arg0)
}

// ModifyInstanceAttributeRequest mocks base method.
func (m *MockEC2API) ModifyInstanceAttributeRequest(arg0 *ec2.ModifyInstanceAttributeInput) (*request.Request, *ec2.ModifyInstanceAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstanceAttributeOutput)
	return ret0, ret1
}

// ModifyInstanceAttributeRequest indicates an expected call of ModifyInstanceAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstanceAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttributeRequest), arg0)
}

// ModifyInstanceAttributeWithContext mocks base method.
func (m *MockEC2API) ModifyInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceAttributeInput, arg2 ...request.Option) (*ec2.ModifyInstanceAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstanceAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstanceCapacityReservationAttributes mocks base method.
func (m *MockEC2API) ModifyInstanceCapacityReservationAttributes(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributes", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceCapacityReservationAttributes indicates an expected call of ModifyInstanceCapacityReservationAttributes.
func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributes", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributes), arg0)
}

// ModifyInstanceCapacityReservationAttributesRequest mocks base method.
func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesRequest(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*request.Request, *ec2.ModifyInstanceCapacityReservationAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
	return ret0, ret1
}

// ModifyInstanceCapacityReservationAttributesRequest indicates an expected call of ModifyInstanceCapacityReservationAttributesRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesRequest), arg0)
}

// ModifyInstanceCapacityReservationAttributesWithContext mocks base method.
func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceCapacityReservationAttributesInput, arg2 ...request.Option) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstanceCreditSpecification mocks base method.
func (m *MockEC2API) ModifyInstanceCreditSpecification(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*ec2.ModifyInstanceCreditSpecificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecification", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceCreditSpecification indicates an expected call of ModifyInstanceCreditSpecification.
func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecification(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecification), arg0)
}

// ModifyInstanceCreditSpecificationRequest mocks base method.
func (m *MockEC2API) ModifyInstanceCreditSpecificationRequest(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*request.Request, *ec2.ModifyInstanceCreditSpecificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstanceCreditSpecificationOutput)
	return ret0, ret1
}

// ModifyInstanceCreditSpecificationRequest indicates an expected call of ModifyInstanceCreditSpecificationRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecificationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecificationRequest), arg0)
}

// ModifyInstanceCreditSpecificationWithContext mocks base method.
func (m *MockEC2API) ModifyInstanceCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyInstanceCreditSpecificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstanceEventStartTime mocks base method.
func (m *MockEC2API) ModifyInstanceEventStartTime(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*ec2.ModifyInstanceEventStartTimeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceEventStartTime", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceEventStartTime indicates an expected call of ModifyInstanceEventStartTime.
func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTime(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTime", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTime), arg0)
}

// ModifyInstanceEventStartTimeRequest mocks base method.
func (m *MockEC2API) ModifyInstanceEventStartTimeRequest(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*request.Request, *ec2.ModifyInstanceEventStartTimeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstanceEventStartTimeOutput)
	return ret0, ret1
}

// ModifyInstanceEventStartTimeRequest indicates an expected call of ModifyInstanceEventStartTimeRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTimeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTimeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTimeRequest), arg0)
}

// ModifyInstanceEventStartTimeWithContext mocks base method.
func (m *MockEC2API) ModifyInstanceEventStartTimeWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceEventStartTimeInput, arg2 ...request.Option) (*ec2.ModifyInstanceEventStartTimeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstanceEventWindow mocks base method.
func (m *MockEC2API) ModifyInstanceEventWindow(arg0 *ec2.ModifyInstanceEventWindowInput) (*ec2.ModifyInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceEventWindow", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceEventWindow indicates an expected call of ModifyInstanceEventWindow.
func (mr *MockEC2APIMockRecorder) ModifyInstanceEventWindow(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventWindow", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventWindow), arg0)
}

// ModifyInstanceEventWindowRequest mocks base method.
func (m *MockEC2API) ModifyInstanceEventWindowRequest(arg0 *ec2.ModifyInstanceEventWindowInput) (*request.Request, *ec2.ModifyInstanceEventWindowOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceEventWindowRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstanceEventWindowOutput)
	return ret0, ret1
}

// ModifyInstanceEventWindowRequest indicates an expected call of ModifyInstanceEventWindowRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstanceEventWindowRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventWindowRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventWindowRequest), arg0)
}

// ModifyInstanceEventWindowWithContext mocks base method.
func (m *MockEC2API) ModifyInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceEventWindowInput, arg2 ...request.Option) (*ec2.ModifyInstanceEventWindowOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstanceEventWindowWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstanceEventWindowOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstanceMaintenanceOptions mocks base method.
func (m *MockEC2API) ModifyInstanceMaintenanceOptions(arg0 *ec2.ModifyInstanceMaintenanceOptionsInput) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptions", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstanceMaintenanceOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceMaintenanceOptions indicates an expected call of ModifyInstanceMaintenanceOptions.
func (mr *MockEC2APIMockRecorder) ModifyInstanceMaintenanceOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMaintenanceOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMaintenanceOptions), arg0)
}

// ModifyInstanceMaintenanceOptionsRequest mocks base method.
func (m *MockEC2API) ModifyInstanceMaintenanceOptionsRequest(arg0 *ec2.ModifyInstanceMaintenanceOptionsInput) (*request.Request, *ec2.ModifyInstanceMaintenanceOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstanceMaintenanceOptionsOutput)
	return ret0, ret1
}

// ModifyInstanceMaintenanceOptionsRequest indicates an expected call of ModifyInstanceMaintenanceOptionsRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstanceMaintenanceOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMaintenanceOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMaintenanceOptionsRequest), arg0)
}

// ModifyInstanceMaintenanceOptionsWithContext mocks base method.
func (m *MockEC2API) ModifyInstanceMaintenanceOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMaintenanceOptionsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstanceMaintenanceOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstanceMetadataDefaults mocks base method.
func (m *MockEC2API) ModifyInstanceMetadataDefaults(arg0 *ec2.ModifyInstanceMetadataDefaultsInput) (*ec2.ModifyInstanceMetadataDefaultsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceMetadataDefaults", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataDefaultsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceMetadataDefaults indicates an expected call of ModifyInstanceMetadataDefaults.
func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataDefaults(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataDefaults", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataDefaults), arg0)
}

// ModifyInstanceMetadataDefaultsRequest mocks base method.
func (m *MockEC2API) ModifyInstanceMetadataDefaultsRequest(arg0 *ec2.ModifyInstanceMetadataDefaultsInput) (*request.Request, *ec2.ModifyInstanceMetadataDefaultsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceMetadataDefaultsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstanceMetadataDefaultsOutput)
	return ret0, ret1
}

// ModifyInstanceMetadataDefaultsRequest indicates an expected call of ModifyInstanceMetadataDefaultsRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataDefaultsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataDefaultsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataDefaultsRequest), arg0)
}

// ModifyInstanceMetadataDefaultsWithContext mocks base method.
func (m *MockEC2API) ModifyInstanceMetadataDefaultsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMetadataDefaultsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMetadataDefaultsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstanceMetadataDefaultsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataDefaultsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstanceMetadataOptions mocks base method.
func (m *MockEC2API) ModifyInstanceMetadataOptions(arg0 *ec2.ModifyInstanceMetadataOptionsInput) (*ec2.ModifyInstanceMetadataOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptions", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceMetadataOptions indicates an expected call of ModifyInstanceMetadataOptions.
func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptions), arg0)
}

// ModifyInstanceMetadataOptionsRequest mocks base method.
func (m *MockEC2API) ModifyInstanceMetadataOptionsRequest(arg0 *ec2.ModifyInstanceMetadataOptionsInput) (*request.Request, *ec2.ModifyInstanceMetadataOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstanceMetadataOptionsOutput)
	return ret0, ret1
}

// ModifyInstanceMetadataOptionsRequest indicates an expected call of ModifyInstanceMetadataOptionsRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptionsRequest), arg0)
}

// ModifyInstanceMetadataOptionsWithContext mocks base method.
func (m *MockEC2API) ModifyInstanceMetadataOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMetadataOptionsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMetadataOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyInstancePlacement mocks base method.
func (m *MockEC2API) ModifyInstancePlacement(arg0 *ec2.ModifyInstancePlacementInput) (*ec2.ModifyInstancePlacementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstancePlacement", arg0)
	ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstancePlacement indicates an expected call of ModifyInstancePlacement.
func (mr *MockEC2APIMockRecorder) ModifyInstancePlacement(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacement", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacement), arg0)
}

// ModifyInstancePlacementRequest mocks base method.
func (m *MockEC2API) ModifyInstancePlacementRequest(arg0 *ec2.ModifyInstancePlacementInput) (*request.Request, *ec2.ModifyInstancePlacementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstancePlacementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyInstancePlacementOutput)
	return ret0, ret1
}

// ModifyInstancePlacementRequest indicates an expected call of ModifyInstancePlacementRequest.
func (mr *MockEC2APIMockRecorder) ModifyInstancePlacementRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacementRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacementRequest), arg0)
}

// ModifyInstancePlacementWithContext mocks base method.
func (m *MockEC2API) ModifyInstancePlacementWithContext(arg0 context.Context, arg1 *ec2.ModifyInstancePlacementInput, arg2 ...request.Option) (*ec2.ModifyInstancePlacementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyInstancePlacementWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyIpam mocks base method.
func (m *MockEC2API) ModifyIpam(arg0 *ec2.ModifyIpamInput) (*ec2.ModifyIpamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpam", arg0)
	ret0, _ := ret[0].(*ec2.ModifyIpamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyIpam indicates an expected call of ModifyIpam.
func (mr *MockEC2APIMockRecorder) ModifyIpam(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpam", reflect.TypeOf((*MockEC2API)(nil).ModifyIpam), arg0)
}

// ModifyIpamPool mocks base method.
func (m *MockEC2API) ModifyIpamPool(arg0 *ec2.ModifyIpamPoolInput) (*ec2.ModifyIpamPoolOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamPool", arg0)
	ret0, _ := ret[0].(*ec2.ModifyIpamPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyIpamPool indicates an expected call of ModifyIpamPool.
func (mr *MockEC2APIMockRecorder) ModifyIpamPool(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamPool", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamPool), arg0)
}

// ModifyIpamPoolRequest mocks base method.
func (m *MockEC2API) ModifyIpamPoolRequest(arg0 *ec2.ModifyIpamPoolInput) (*request.Request, *ec2.ModifyIpamPoolOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamPoolRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyIpamPoolOutput)
	return ret0, ret1
}

// ModifyIpamPoolRequest indicates an expected call of ModifyIpamPoolRequest.
func (mr *MockEC2APIMockRecorder) ModifyIpamPoolRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamPoolRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamPoolRequest), arg0)
}

// ModifyIpamPoolWithContext mocks base method.
func (m *MockEC2API) ModifyIpamPoolWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamPoolInput, arg2 ...request.Option) (*ec2.ModifyIpamPoolOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyIpamPoolWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyIpamPoolOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyIpamRequest mocks base method.
func (m *MockEC2API) ModifyIpamRequest(arg0 *ec2.ModifyIpamInput) (*request.Request, *ec2.ModifyIpamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyIpamOutput)
	return ret0, ret1
}

// ModifyIpamRequest indicates an expected call of ModifyIpamRequest.
func (mr *MockEC2APIMockRecorder) ModifyIpamRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamRequest), arg0)
}

// ModifyIpamResourceCidr mocks base method.
func (m *MockEC2API) ModifyIpamResourceCidr(arg0 *ec2.ModifyIpamResourceCidrInput) (*ec2.ModifyIpamResourceCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamResourceCidr", arg0)
	ret0, _ := ret[0].(*ec2.ModifyIpamResourceCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyIpamResourceCidr indicates an expected call of ModifyIpamResourceCidr.
func (mr *MockEC2APIMockRecorder) ModifyIpamResourceCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceCidr", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceCidr), arg0)
}

// ModifyIpamResourceCidrRequest mocks base method.
func (m *MockEC2API) ModifyIpamResourceCidrRequest(arg0 *ec2.ModifyIpamResourceCidrInput) (*request.Request, *ec2.ModifyIpamResourceCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamResourceCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyIpamResourceCidrOutput)
	return ret0, ret1
}

// ModifyIpamResourceCidrRequest indicates an expected call of ModifyIpamResourceCidrRequest.
func (mr *MockEC2APIMockRecorder) ModifyIpamResourceCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceCidrRequest), arg0)
}

// ModifyIpamResourceCidrWithContext mocks base method.
func (m *MockEC2API) ModifyIpamResourceCidrWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamResourceCidrInput, arg2 ...request.Option) (*ec2.ModifyIpamResourceCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyIpamResourceCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyIpamResourceCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyIpamResourceDiscovery mocks base method.
func (m *MockEC2API) ModifyIpamResourceDiscovery(arg0 *ec2.ModifyIpamResourceDiscoveryInput) (*ec2.ModifyIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamResourceDiscovery", arg0)
	ret0, _ := ret[0].(*ec2.ModifyIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyIpamResourceDiscovery indicates an expected call of ModifyIpamResourceDiscovery.
func (mr *MockEC2APIMockRecorder) ModifyIpamResourceDiscovery(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceDiscovery", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceDiscovery), arg0)
}

// ModifyIpamResourceDiscoveryRequest mocks base method.
func (m *MockEC2API) ModifyIpamResourceDiscoveryRequest(arg0 *ec2.ModifyIpamResourceDiscoveryInput) (*request.Request, *ec2.ModifyIpamResourceDiscoveryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamResourceDiscoveryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyIpamResourceDiscoveryOutput)
	return ret0, ret1
}

// ModifyIpamResourceDiscoveryRequest indicates an expected call of ModifyIpamResourceDiscoveryRequest.
func (mr *MockEC2APIMockRecorder) ModifyIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamResourceDiscoveryRequest), arg0)
}

// ModifyIpamResourceDiscoveryWithContext mocks base method.
func (m *MockEC2API) ModifyIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.ModifyIpamResourceDiscoveryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyIpamResourceDiscoveryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyIpamResourceDiscoveryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyIpamScope mocks base method.
func (m *MockEC2API) ModifyIpamScope(arg0 *ec2.ModifyIpamScopeInput) (*ec2.ModifyIpamScopeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamScope", arg0)
	ret0, _ := ret[0].(*ec2.ModifyIpamScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyIpamScope indicates an expected call of ModifyIpamScope.
func (mr *MockEC2APIMockRecorder) ModifyIpamScope(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamScope", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamScope), arg0)
}

// ModifyIpamScopeRequest mocks base method.
func (m *MockEC2API) ModifyIpamScopeRequest(arg0 *ec2.ModifyIpamScopeInput) (*request.Request, *ec2.ModifyIpamScopeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyIpamScopeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyIpamScopeOutput)
	return ret0, ret1
}

// ModifyIpamScopeRequest indicates an expected call of ModifyIpamScopeRequest.
func (mr *MockEC2APIMockRecorder) ModifyIpamScopeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamScopeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIpamScopeRequest), arg0)
}

// ModifyIpamScopeWithContext mocks base method.
func (m *MockEC2API) ModifyIpamScopeWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamScopeInput, arg2 ...request.Option) (*ec2.ModifyIpamScopeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyIpamScopeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyIpamScopeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyIpamWithContext mocks base method.
func (m *MockEC2API) ModifyIpamWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamInput, arg2 ...request.Option) (*ec2.ModifyIpamOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyIpamWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyIpamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyLaunchTemplate mocks base method.
func (m *MockEC2API) ModifyLaunchTemplate(arg0 *ec2.ModifyLaunchTemplateInput) (*ec2.ModifyLaunchTemplateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyLaunchTemplate", arg0)
	ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyLaunchTemplate indicates an expected call of ModifyLaunchTemplate.
func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplate), arg0)
}

// ModifyLaunchTemplateRequest mocks base method.
func (m *MockEC2API) ModifyLaunchTemplateRequest(arg0 *ec2.ModifyLaunchTemplateInput) (*request.Request, *ec2.ModifyLaunchTemplateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyLaunchTemplateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyLaunchTemplateOutput)
	return ret0, ret1
}

// ModifyLaunchTemplateRequest indicates an expected call of ModifyLaunchTemplateRequest.
func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplateRequest), arg0)
}

// ModifyLaunchTemplateWithContext mocks base method.
func (m *MockEC2API) ModifyLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.ModifyLaunchTemplateInput, arg2 ...request.Option) (*ec2.ModifyLaunchTemplateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyLaunchTemplateWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyLocalGatewayRoute mocks base method.
func (m *MockEC2API) ModifyLocalGatewayRoute(arg0 *ec2.ModifyLocalGatewayRouteInput) (*ec2.ModifyLocalGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyLocalGatewayRoute", arg0)
	ret0, _ := ret[0].(*ec2.ModifyLocalGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyLocalGatewayRoute indicates an expected call of ModifyLocalGatewayRoute.
func (mr *MockEC2APIMockRecorder) ModifyLocalGatewayRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).ModifyLocalGatewayRoute), arg0)
}

// ModifyLocalGatewayRouteRequest mocks base method.
func (m *MockEC2API) ModifyLocalGatewayRouteRequest(arg0 *ec2.ModifyLocalGatewayRouteInput) (*request.Request, *ec2.ModifyLocalGatewayRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyLocalGatewayRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyLocalGatewayRouteOutput)
	return ret0, ret1
}

// ModifyLocalGatewayRouteRequest indicates an expected call of ModifyLocalGatewayRouteRequest.
func (mr *MockEC2APIMockRecorder) ModifyLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyLocalGatewayRouteRequest), arg0)
}

// ModifyLocalGatewayRouteWithContext mocks base method.
func (m *MockEC2API) ModifyLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.ModifyLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.ModifyLocalGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyLocalGatewayRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyLocalGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyManagedPrefixList mocks base method.
func (m *MockEC2API) ModifyManagedPrefixList(arg0 *ec2.ModifyManagedPrefixListInput) (*ec2.ModifyManagedPrefixListOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyManagedPrefixList", arg0)
	ret0, _ := ret[0].(*ec2.ModifyManagedPrefixListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyManagedPrefixList indicates an expected call of ModifyManagedPrefixList.
func (mr *MockEC2APIMockRecorder) ModifyManagedPrefixList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).ModifyManagedPrefixList), arg0)
}

// ModifyManagedPrefixListRequest mocks base method.
func (m *MockEC2API) ModifyManagedPrefixListRequest(arg0 *ec2.ModifyManagedPrefixListInput) (*request.Request, *ec2.ModifyManagedPrefixListOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyManagedPrefixListRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyManagedPrefixListOutput)
	return ret0, ret1
}

// ModifyManagedPrefixListRequest indicates an expected call of ModifyManagedPrefixListRequest.
func (mr *MockEC2APIMockRecorder) ModifyManagedPrefixListRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyManagedPrefixListRequest), arg0)
}

// ModifyManagedPrefixListWithContext mocks base method.
func (m *MockEC2API) ModifyManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.ModifyManagedPrefixListInput, arg2 ...request.Option) (*ec2.ModifyManagedPrefixListOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyManagedPrefixListWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyManagedPrefixListOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyNetworkInterfaceAttribute mocks base method.
func (m *MockEC2API) ModifyNetworkInterfaceAttribute(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyNetworkInterfaceAttribute indicates an expected call of ModifyNetworkInterfaceAttribute.
func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttribute), arg0)
}

// ModifyNetworkInterfaceAttributeRequest mocks base method.
func (m *MockEC2API) ModifyNetworkInterfaceAttributeRequest(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*request.Request, *ec2.ModifyNetworkInterfaceAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyNetworkInterfaceAttributeOutput)
	return ret0, ret1
}

// ModifyNetworkInterfaceAttributeRequest indicates an expected call of ModifyNetworkInterfaceAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeRequest), arg0)
}

// ModifyNetworkInterfaceAttributeWithContext mocks base method.
func (m *MockEC2API) ModifyNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyPrivateDnsNameOptions mocks base method.
func (m *MockEC2API) ModifyPrivateDnsNameOptions(arg0 *ec2.ModifyPrivateDnsNameOptionsInput) (*ec2.ModifyPrivateDnsNameOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptions", arg0)
	ret0, _ := ret[0].(*ec2.ModifyPrivateDnsNameOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyPrivateDnsNameOptions indicates an expected call of ModifyPrivateDnsNameOptions.
func (mr *MockEC2APIMockRecorder) ModifyPrivateDnsNameOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyPrivateDnsNameOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyPrivateDnsNameOptions), arg0)
}

// ModifyPrivateDnsNameOptionsRequest mocks base method.
func (m *MockEC2API) ModifyPrivateDnsNameOptionsRequest(arg0 *ec2.ModifyPrivateDnsNameOptionsInput) (*request.Request, *ec2.ModifyPrivateDnsNameOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyPrivateDnsNameOptionsOutput)
	return ret0, ret1
}

// ModifyPrivateDnsNameOptionsRequest indicates an expected call of ModifyPrivateDnsNameOptionsRequest.
func (mr *MockEC2APIMockRecorder) ModifyPrivateDnsNameOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyPrivateDnsNameOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyPrivateDnsNameOptionsRequest), arg0)
}

// ModifyPrivateDnsNameOptionsWithContext mocks base method.
func (m *MockEC2API) ModifyPrivateDnsNameOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyPrivateDnsNameOptionsInput, arg2 ...request.Option) (*ec2.ModifyPrivateDnsNameOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyPrivateDnsNameOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyReservedInstances mocks base method.
func (m *MockEC2API) ModifyReservedInstances(arg0 *ec2.ModifyReservedInstancesInput) (*ec2.ModifyReservedInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyReservedInstances", arg0)
	ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyReservedInstances indicates an expected call of ModifyReservedInstances.
func (mr *MockEC2APIMockRecorder) ModifyReservedInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstances", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstances), arg0)
}

// ModifyReservedInstancesRequest mocks base method.
func (m *MockEC2API) ModifyReservedInstancesRequest(arg0 *ec2.ModifyReservedInstancesInput) (*request.Request, *ec2.ModifyReservedInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyReservedInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyReservedInstancesOutput)
	return ret0, ret1
}

// ModifyReservedInstancesRequest indicates an expected call of ModifyReservedInstancesRequest.
func (mr *MockEC2APIMockRecorder) ModifyReservedInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstancesRequest), arg0)
}

// ModifyReservedInstancesWithContext mocks base method.
func (m *MockEC2API) ModifyReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.ModifyReservedInstancesInput, arg2 ...request.Option) (*ec2.ModifyReservedInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyReservedInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifySecurityGroupRules mocks base method.
func (m *MockEC2API) ModifySecurityGroupRules(arg0 *ec2.ModifySecurityGroupRulesInput) (*ec2.ModifySecurityGroupRulesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySecurityGroupRules", arg0)
	ret0, _ := ret[0].(*ec2.ModifySecurityGroupRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySecurityGroupRules indicates an expected call of ModifySecurityGroupRules.
func (mr *MockEC2APIMockRecorder) ModifySecurityGroupRules(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupRules", reflect.TypeOf((*MockEC2API)(nil).ModifySecurityGroupRules), arg0)
}

// ModifySecurityGroupRulesRequest mocks base method.
func (m *MockEC2API) ModifySecurityGroupRulesRequest(arg0 *ec2.ModifySecurityGroupRulesInput) (*request.Request, *ec2.ModifySecurityGroupRulesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySecurityGroupRulesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifySecurityGroupRulesOutput)
	return ret0, ret1
}

// ModifySecurityGroupRulesRequest indicates an expected call of ModifySecurityGroupRulesRequest.
func (mr *MockEC2APIMockRecorder) ModifySecurityGroupRulesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupRulesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySecurityGroupRulesRequest), arg0)
}

// ModifySecurityGroupRulesWithContext mocks base method.
func (m *MockEC2API) ModifySecurityGroupRulesWithContext(arg0 context.Context, arg1 *ec2.ModifySecurityGroupRulesInput, arg2 ...request.Option) (*ec2.ModifySecurityGroupRulesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifySecurityGroupRulesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifySecurityGroupRulesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifySnapshotAttribute mocks base method.
func (m *MockEC2API) ModifySnapshotAttribute(arg0 *ec2.ModifySnapshotAttributeInput) (*ec2.ModifySnapshotAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySnapshotAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySnapshotAttribute indicates an expected call of ModifySnapshotAttribute.
func (mr *MockEC2APIMockRecorder) ModifySnapshotAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttribute), arg0)
}

// ModifySnapshotAttributeRequest mocks base method.
func (m *MockEC2API) ModifySnapshotAttributeRequest(arg0 *ec2.ModifySnapshotAttributeInput) (*request.Request, *ec2.ModifySnapshotAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySnapshotAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifySnapshotAttributeOutput)
	return ret0, ret1
}

// ModifySnapshotAttributeRequest indicates an expected call of ModifySnapshotAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifySnapshotAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttributeRequest), arg0)
}

// ModifySnapshotAttributeWithContext mocks base method.
func (m *MockEC2API) ModifySnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifySnapshotAttributeInput, arg2 ...request.Option) (*ec2.ModifySnapshotAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifySnapshotAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifySnapshotTier mocks base method.
func (m *MockEC2API) ModifySnapshotTier(arg0 *ec2.ModifySnapshotTierInput) (*ec2.ModifySnapshotTierOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySnapshotTier", arg0)
	ret0, _ := ret[0].(*ec2.ModifySnapshotTierOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySnapshotTier indicates an expected call of ModifySnapshotTier.
func (mr *MockEC2APIMockRecorder) ModifySnapshotTier(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotTier", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotTier), arg0)
}

// ModifySnapshotTierRequest mocks base method.
func (m *MockEC2API) ModifySnapshotTierRequest(arg0 *ec2.ModifySnapshotTierInput) (*request.Request, *ec2.ModifySnapshotTierOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySnapshotTierRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifySnapshotTierOutput)
	return ret0, ret1
}

// ModifySnapshotTierRequest indicates an expected call of ModifySnapshotTierRequest.
func (mr *MockEC2APIMockRecorder) ModifySnapshotTierRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotTierRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotTierRequest), arg0)
}

// ModifySnapshotTierWithContext mocks base method.
func (m *MockEC2API) ModifySnapshotTierWithContext(arg0 context.Context, arg1 *ec2.ModifySnapshotTierInput, arg2 ...request.Option) (*ec2.ModifySnapshotTierOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifySnapshotTierWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifySnapshotTierOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifySpotFleetRequest mocks base method.
func (m *MockEC2API) ModifySpotFleetRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*ec2.ModifySpotFleetRequestOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySpotFleetRequest", arg0)
	ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySpotFleetRequest indicates an expected call of ModifySpotFleetRequest.
func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequest), arg0)
}

// ModifySpotFleetRequestRequest mocks base method.
func (m *MockEC2API) ModifySpotFleetRequestRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*request.Request, *ec2.ModifySpotFleetRequestOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySpotFleetRequestRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifySpotFleetRequestOutput)
	return ret0, ret1
}

// ModifySpotFleetRequestRequest indicates an expected call of ModifySpotFleetRequestRequest.
func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequestRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequestRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequestRequest), arg0)
}

// ModifySpotFleetRequestWithContext mocks base method.
func (m *MockEC2API) ModifySpotFleetRequestWithContext(arg0 context.Context, arg1 *ec2.ModifySpotFleetRequestInput, arg2 ...request.Option) (*ec2.ModifySpotFleetRequestOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifySpotFleetRequestWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifySubnetAttribute mocks base method.
func (m *MockEC2API) ModifySubnetAttribute(arg0 *ec2.ModifySubnetAttributeInput) (*ec2.ModifySubnetAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySubnetAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySubnetAttribute indicates an expected call of ModifySubnetAttribute.
func (mr *MockEC2APIMockRecorder) ModifySubnetAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttribute), arg0)
}

// ModifySubnetAttributeRequest mocks base method.
func (m *MockEC2API) ModifySubnetAttributeRequest(arg0 *ec2.ModifySubnetAttributeInput) (*request.Request, *ec2.ModifySubnetAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySubnetAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifySubnetAttributeOutput)
	return ret0, ret1
}

// ModifySubnetAttributeRequest indicates an expected call of ModifySubnetAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifySubnetAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttributeRequest), arg0)
}

// ModifySubnetAttributeWithContext mocks base method.
func (m *MockEC2API) ModifySubnetAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifySubnetAttributeInput, arg2 ...request.Option) (*ec2.ModifySubnetAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifySubnetAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyTrafficMirrorFilterNetworkServices mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServices(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServices", arg0)
	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyTrafficMirrorFilterNetworkServices indicates an expected call of ModifyTrafficMirrorFilterNetworkServices.
func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServices(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServices", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServices), arg0)
}

// ModifyTrafficMirrorFilterNetworkServicesRequest mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
	return ret0, ret1
}

// ModifyTrafficMirrorFilterNetworkServicesRequest indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesRequest.
func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServicesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesRequest), arg0)
}

// ModifyTrafficMirrorFilterNetworkServicesWithContext mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyTrafficMirrorFilterRule mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorFilterRule(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRule", arg0)
	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyTrafficMirrorFilterRule indicates an expected call of ModifyTrafficMirrorFilterRule.
func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRule), arg0)
}

// ModifyTrafficMirrorFilterRuleRequest mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorFilterRuleRequest(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterRuleOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterRuleOutput)
	return ret0, ret1
}

// ModifyTrafficMirrorFilterRuleRequest indicates an expected call of ModifyTrafficMirrorFilterRuleRequest.
func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleRequest), arg0)
}

// ModifyTrafficMirrorFilterRuleWithContext mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyTrafficMirrorSession mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorSession(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*ec2.ModifyTrafficMirrorSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorSession", arg0)
	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyTrafficMirrorSession indicates an expected call of ModifyTrafficMirrorSession.
func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSession(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSession), arg0)
}

// ModifyTrafficMirrorSessionRequest mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorSessionRequest(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*request.Request, *ec2.ModifyTrafficMirrorSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorSessionOutput)
	return ret0, ret1
}

// ModifyTrafficMirrorSessionRequest indicates an expected call of ModifyTrafficMirrorSessionRequest.
func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSessionRequest), arg0)
}

// ModifyTrafficMirrorSessionWithContext mocks base method.
func (m *MockEC2API) ModifyTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyTransitGateway mocks base method.
func (m *MockEC2API) ModifyTransitGateway(arg0 *ec2.ModifyTransitGatewayInput) (*ec2.ModifyTransitGatewayOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTransitGateway", arg0)
	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyTransitGateway indicates an expected call of ModifyTransitGateway.
func (mr *MockEC2APIMockRecorder) ModifyTransitGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGateway", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGateway), arg0)
}

// ModifyTransitGatewayPrefixListReference mocks base method.
func (m *MockEC2API) ModifyTransitGatewayPrefixListReference(arg0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReference", arg0)
	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyTransitGatewayPrefixListReference indicates an expected call of ModifyTransitGatewayPrefixListReference.
func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayPrefixListReference), arg0)
}

// ModifyTransitGatewayPrefixListReferenceRequest mocks base method.
func (m *MockEC2API) ModifyTransitGatewayPrefixListReferenceRequest(arg0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.ModifyTransitGatewayPrefixListReferenceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReferenceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
	return ret0, ret1
}

// ModifyTransitGatewayPrefixListReferenceRequest indicates an expected call of ModifyTransitGatewayPrefixListReferenceRequest.
func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayPrefixListReferenceRequest), arg0)
}

// ModifyTransitGatewayPrefixListReferenceWithContext mocks base method.
func (m *MockEC2API) ModifyTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReferenceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyTransitGatewayRequest mocks base method.
func (m *MockEC2API) ModifyTransitGatewayRequest(arg0 *ec2.ModifyTransitGatewayInput) (*request.Request, *ec2.ModifyTransitGatewayOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTransitGatewayRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyTransitGatewayOutput)
	return ret0, ret1
}

// ModifyTransitGatewayRequest indicates an expected call of ModifyTransitGatewayRequest.
func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayRequest), arg0)
}

// ModifyTransitGatewayVpcAttachment mocks base method.
func (m *MockEC2API) ModifyTransitGatewayVpcAttachment(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachment", arg0)
	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyTransitGatewayVpcAttachment indicates an expected call of ModifyTransitGatewayVpcAttachment.
func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachment), arg0)
}

// ModifyTransitGatewayVpcAttachmentRequest mocks base method.
func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentRequest(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.ModifyTransitGatewayVpcAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
	return ret0, ret1
}

// ModifyTransitGatewayVpcAttachmentRequest indicates an expected call of ModifyTransitGatewayVpcAttachmentRequest.
func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentRequest), arg0)
}

// ModifyTransitGatewayVpcAttachmentWithContext mocks base method.
func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyTransitGatewayWithContext mocks base method.
func (m *MockEC2API) ModifyTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyTransitGatewayWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyTransitGatewayOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVerifiedAccessEndpoint mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessEndpoint(arg0 *ec2.ModifyVerifiedAccessEndpointInput) (*ec2.ModifyVerifiedAccessEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVerifiedAccessEndpoint indicates an expected call of ModifyVerifiedAccessEndpoint.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpoint), arg0)
}

// ModifyVerifiedAccessEndpointPolicy mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessEndpointPolicy(arg0 *ec2.ModifyVerifiedAccessEndpointPolicyInput) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicy", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVerifiedAccessEndpointPolicy indicates an expected call of ModifyVerifiedAccessEndpointPolicy.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpointPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointPolicy", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpointPolicy), arg0)
}

// ModifyVerifiedAccessEndpointPolicyRequest mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessEndpointPolicyRequest(arg0 *ec2.ModifyVerifiedAccessEndpointPolicyInput) (*request.Request, *ec2.ModifyVerifiedAccessEndpointPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput)
	return ret0, ret1
}

// ModifyVerifiedAccessEndpointPolicyRequest indicates an expected call of ModifyVerifiedAccessEndpointPolicyRequest.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpointPolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointPolicyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpointPolicyRequest), arg0)
}

// ModifyVerifiedAccessEndpointPolicyWithContext mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessEndpointPolicyWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessEndpointPolicyInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVerifiedAccessEndpointRequest mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessEndpointRequest(arg0 *ec2.ModifyVerifiedAccessEndpointInput) (*request.Request, *ec2.ModifyVerifiedAccessEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessEndpointOutput)
	return ret0, ret1
}

// ModifyVerifiedAccessEndpointRequest indicates an expected call of ModifyVerifiedAccessEndpointRequest.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessEndpointRequest), arg0)
}

// ModifyVerifiedAccessEndpointWithContext mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVerifiedAccessGroup mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessGroup(arg0 *ec2.ModifyVerifiedAccessGroupInput) (*ec2.ModifyVerifiedAccessGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroup", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVerifiedAccessGroup indicates an expected call of ModifyVerifiedAccessGroup.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroup", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroup), arg0)
}

// ModifyVerifiedAccessGroupPolicy mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessGroupPolicy(arg0 *ec2.ModifyVerifiedAccessGroupPolicyInput) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicy", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVerifiedAccessGroupPolicy indicates an expected call of ModifyVerifiedAccessGroupPolicy.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroupPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupPolicy", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroupPolicy), arg0)
}

// ModifyVerifiedAccessGroupPolicyRequest mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessGroupPolicyRequest(arg0 *ec2.ModifyVerifiedAccessGroupPolicyInput) (*request.Request, *ec2.ModifyVerifiedAccessGroupPolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessGroupPolicyOutput)
	return ret0, ret1
}

// ModifyVerifiedAccessGroupPolicyRequest indicates an expected call of ModifyVerifiedAccessGroupPolicyRequest.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroupPolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupPolicyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroupPolicyRequest), arg0)
}

// ModifyVerifiedAccessGroupPolicyWithContext mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessGroupPolicyWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessGroupPolicyInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicyWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupPolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVerifiedAccessGroupRequest mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessGroupRequest(arg0 *ec2.ModifyVerifiedAccessGroupInput) (*request.Request, *ec2.ModifyVerifiedAccessGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessGroupOutput)
	return ret0, ret1
}

// ModifyVerifiedAccessGroupRequest indicates an expected call of ModifyVerifiedAccessGroupRequest.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessGroupRequest), arg0)
}

// ModifyVerifiedAccessGroupWithContext mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVerifiedAccessInstance mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessInstance(arg0 *ec2.ModifyVerifiedAccessInstanceInput) (*ec2.ModifyVerifiedAccessInstanceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstance", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVerifiedAccessInstance indicates an expected call of ModifyVerifiedAccessInstance.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstance", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstance), arg0)
}

// ModifyVerifiedAccessInstanceLoggingConfiguration mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessInstanceLoggingConfiguration(arg0 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfiguration", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVerifiedAccessInstanceLoggingConfiguration indicates an expected call of ModifyVerifiedAccessInstanceLoggingConfiguration.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstanceLoggingConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceLoggingConfiguration", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstanceLoggingConfiguration), arg0)
}

// ModifyVerifiedAccessInstanceLoggingConfigurationRequest mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessInstanceLoggingConfigurationRequest(arg0 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput) (*request.Request, *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput)
	return ret0, ret1
}

// ModifyVerifiedAccessInstanceLoggingConfigurationRequest indicates an expected call of ModifyVerifiedAccessInstanceLoggingConfigurationRequest.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstanceLoggingConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceLoggingConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstanceLoggingConfigurationRequest), arg0)
}

// ModifyVerifiedAccessInstanceLoggingConfigurationWithContext mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessInstanceLoggingConfigurationWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVerifiedAccessInstanceRequest mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessInstanceRequest(arg0 *ec2.ModifyVerifiedAccessInstanceInput) (*request.Request, *ec2.ModifyVerifiedAccessInstanceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessInstanceOutput)
	return ret0, ret1
}

// ModifyVerifiedAccessInstanceRequest indicates an expected call of ModifyVerifiedAccessInstanceRequest.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessInstanceRequest), arg0)
}

// ModifyVerifiedAccessInstanceWithContext mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessInstanceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVerifiedAccessTrustProvider mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessTrustProvider(arg0 *ec2.ModifyVerifiedAccessTrustProviderInput) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProvider", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVerifiedAccessTrustProvider indicates an expected call of ModifyVerifiedAccessTrustProvider.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessTrustProvider), arg0)
}

// ModifyVerifiedAccessTrustProviderRequest mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessTrustProviderRequest(arg0 *ec2.ModifyVerifiedAccessTrustProviderInput) (*request.Request, *ec2.ModifyVerifiedAccessTrustProviderOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProviderRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessTrustProviderOutput)
	return ret0, ret1
}

// ModifyVerifiedAccessTrustProviderRequest indicates an expected call of ModifyVerifiedAccessTrustProviderRequest.
func (mr *MockEC2APIMockRecorder) ModifyVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVerifiedAccessTrustProviderRequest), arg0)
}

// ModifyVerifiedAccessTrustProviderWithContext mocks base method.
func (m *MockEC2API) ModifyVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProviderWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessTrustProviderOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVolume mocks base method.
func (m *MockEC2API) ModifyVolume(arg0 *ec2.ModifyVolumeInput) (*ec2.ModifyVolumeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVolume", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVolumeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVolume indicates an expected call of ModifyVolume.
func (mr *MockEC2APIMockRecorder) ModifyVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolume", reflect.TypeOf((*MockEC2API)(nil).ModifyVolume), arg0)
}

// ModifyVolumeAttribute mocks base method.
func (m *MockEC2API) ModifyVolumeAttribute(arg0 *ec2.ModifyVolumeAttributeInput) (*ec2.ModifyVolumeAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVolumeAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVolumeAttribute indicates an expected call of ModifyVolumeAttribute.
func (mr *MockEC2APIMockRecorder) ModifyVolumeAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttribute), arg0)
}

// ModifyVolumeAttributeRequest mocks base method.
func (m *MockEC2API) ModifyVolumeAttributeRequest(arg0 *ec2.ModifyVolumeAttributeInput) (*request.Request, *ec2.ModifyVolumeAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVolumeAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVolumeAttributeOutput)
	return ret0, ret1
}

// ModifyVolumeAttributeRequest indicates an expected call of ModifyVolumeAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifyVolumeAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttributeRequest), arg0)
}

// ModifyVolumeAttributeWithContext mocks base method.
func (m *MockEC2API) ModifyVolumeAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeAttributeInput, arg2 ...request.Option) (*ec2.ModifyVolumeAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVolumeAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVolumeRequest mocks base method.
func (m *MockEC2API) ModifyVolumeRequest(arg0 *ec2.ModifyVolumeInput) (*request.Request, *ec2.ModifyVolumeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVolumeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVolumeOutput)
	return ret0, ret1
}

// ModifyVolumeRequest indicates an expected call of ModifyVolumeRequest.
func (mr *MockEC2APIMockRecorder) ModifyVolumeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeRequest), arg0)
}

// ModifyVolumeWithContext mocks base method.
func (m *MockEC2API) ModifyVolumeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeInput, arg2 ...request.Option) (*ec2.ModifyVolumeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVolumeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVolumeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpcAttribute mocks base method.
func (m *MockEC2API) ModifyVpcAttribute(arg0 *ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpcAttribute indicates an expected call of ModifyVpcAttribute.
func (mr *MockEC2APIMockRecorder) ModifyVpcAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttribute), arg0)
}

// ModifyVpcAttributeRequest mocks base method.
func (m *MockEC2API) ModifyVpcAttributeRequest(arg0 *ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpcAttributeOutput)
	return ret0, ret1
}

// ModifyVpcAttributeRequest indicates an expected call of ModifyVpcAttributeRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpcAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttributeRequest), arg0)
}

// ModifyVpcAttributeWithContext mocks base method.
func (m *MockEC2API) ModifyVpcAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcAttributeInput, arg2 ...request.Option) (*ec2.ModifyVpcAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpcAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpcEndpoint mocks base method.
func (m *MockEC2API) ModifyVpcEndpoint(arg0 *ec2.ModifyVpcEndpointInput) (*ec2.ModifyVpcEndpointOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpoint", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpcEndpoint indicates an expected call of ModifyVpcEndpoint.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpoint), arg0)
}

// ModifyVpcEndpointConnectionNotification mocks base method.
func (m *MockEC2API) ModifyVpcEndpointConnectionNotification(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotification", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpcEndpointConnectionNotification indicates an expected call of ModifyVpcEndpointConnectionNotification.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotification), arg0)
}

// ModifyVpcEndpointConnectionNotificationRequest mocks base method.
func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationRequest(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.ModifyVpcEndpointConnectionNotificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
	return ret0, ret1
}

// ModifyVpcEndpointConnectionNotificationRequest indicates an expected call of ModifyVpcEndpointConnectionNotificationRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationRequest), arg0)
}

// ModifyVpcEndpointConnectionNotificationWithContext mocks base method.
func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpcEndpointRequest mocks base method.
func (m *MockEC2API) ModifyVpcEndpointRequest(arg0 *ec2.ModifyVpcEndpointInput) (*request.Request, *ec2.ModifyVpcEndpointOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointOutput)
	return ret0, ret1
}

// ModifyVpcEndpointRequest indicates an expected call of ModifyVpcEndpointRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointRequest), arg0)
}

// ModifyVpcEndpointServiceConfiguration mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServiceConfiguration(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfiguration", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpcEndpointServiceConfiguration indicates an expected call of ModifyVpcEndpointServiceConfiguration.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfiguration), arg0)
}

// ModifyVpcEndpointServiceConfigurationRequest mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationRequest(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.ModifyVpcEndpointServiceConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
	return ret0, ret1
}

// ModifyVpcEndpointServiceConfigurationRequest indicates an expected call of ModifyVpcEndpointServiceConfigurationRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationRequest), arg0)
}

// ModifyVpcEndpointServiceConfigurationWithContext mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpcEndpointServicePayerResponsibility mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServicePayerResponsibility(arg0 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibility", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpcEndpointServicePayerResponsibility indicates an expected call of ModifyVpcEndpointServicePayerResponsibility.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePayerResponsibility(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePayerResponsibility", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePayerResponsibility), arg0)
}

// ModifyVpcEndpointServicePayerResponsibilityRequest mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServicePayerResponsibilityRequest(arg0 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput) (*request.Request, *ec2.ModifyVpcEndpointServicePayerResponsibilityOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibilityRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput)
	return ret0, ret1
}

// ModifyVpcEndpointServicePayerResponsibilityRequest indicates an expected call of ModifyVpcEndpointServicePayerResponsibilityRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePayerResponsibilityRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePayerResponsibilityRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePayerResponsibilityRequest), arg0)
}

// ModifyVpcEndpointServicePayerResponsibilityWithContext mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServicePayerResponsibilityWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibilityWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpcEndpointServicePermissions mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServicePermissions(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissions", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpcEndpointServicePermissions indicates an expected call of ModifyVpcEndpointServicePermissions.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissions), arg0)
}

// ModifyVpcEndpointServicePermissionsRequest mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServicePermissionsRequest(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*request.Request, *ec2.ModifyVpcEndpointServicePermissionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServicePermissionsOutput)
	return ret0, ret1
}

// ModifyVpcEndpointServicePermissionsRequest indicates an expected call of ModifyVpcEndpointServicePermissionsRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsRequest), arg0)
}

// ModifyVpcEndpointServicePermissionsWithContext mocks base method.
func (m *MockEC2API) ModifyVpcEndpointServicePermissionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpcEndpointWithContext mocks base method.
func (m *MockEC2API) ModifyVpcEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpcEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpcPeeringConnectionOptions mocks base method.
func (m *MockEC2API) ModifyVpcPeeringConnectionOptions(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptions", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpcPeeringConnectionOptions indicates an expected call of ModifyVpcPeeringConnectionOptions.
func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptions), arg0)
}

// ModifyVpcPeeringConnectionOptionsRequest mocks base method.
func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsRequest(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*request.Request, *ec2.ModifyVpcPeeringConnectionOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
	return ret0, ret1
}

// ModifyVpcPeeringConnectionOptionsRequest indicates an expected call of ModifyVpcPeeringConnectionOptionsRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsRequest), arg0)
}

// ModifyVpcPeeringConnectionOptionsWithContext mocks base method.
func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcPeeringConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpcTenancy mocks base method.
func (m *MockEC2API) ModifyVpcTenancy(arg0 *ec2.ModifyVpcTenancyInput) (*ec2.ModifyVpcTenancyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcTenancy", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpcTenancy indicates an expected call of ModifyVpcTenancy.
func (mr *MockEC2APIMockRecorder) ModifyVpcTenancy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancy", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancy), arg0)
}

// ModifyVpcTenancyRequest mocks base method.
func (m *MockEC2API) ModifyVpcTenancyRequest(arg0 *ec2.ModifyVpcTenancyInput) (*request.Request, *ec2.ModifyVpcTenancyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpcTenancyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpcTenancyOutput)
	return ret0, ret1
}

// ModifyVpcTenancyRequest indicates an expected call of ModifyVpcTenancyRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpcTenancyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancyRequest), arg0)
}

// ModifyVpcTenancyWithContext mocks base method.
func (m *MockEC2API) ModifyVpcTenancyWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcTenancyInput, arg2 ...request.Option) (*ec2.ModifyVpcTenancyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpcTenancyWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpnConnection mocks base method.
func (m *MockEC2API) ModifyVpnConnection(arg0 *ec2.ModifyVpnConnectionInput) (*ec2.ModifyVpnConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpnConnection", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpnConnection indicates an expected call of ModifyVpnConnection.
func (mr *MockEC2APIMockRecorder) ModifyVpnConnection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnection", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnection), arg0)
}

// ModifyVpnConnectionOptions mocks base method.
func (m *MockEC2API) ModifyVpnConnectionOptions(arg0 *ec2.ModifyVpnConnectionOptionsInput) (*ec2.ModifyVpnConnectionOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpnConnectionOptions", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpnConnectionOptions indicates an expected call of ModifyVpnConnectionOptions.
func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionOptions), arg0)
}

// ModifyVpnConnectionOptionsRequest mocks base method.
func (m *MockEC2API) ModifyVpnConnectionOptionsRequest(arg0 *ec2.ModifyVpnConnectionOptionsInput) (*request.Request, *ec2.ModifyVpnConnectionOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpnConnectionOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOptionsOutput)
	return ret0, ret1
}

// ModifyVpnConnectionOptionsRequest indicates an expected call of ModifyVpnConnectionOptionsRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionOptionsRequest), arg0)
}

// ModifyVpnConnectionOptionsWithContext mocks base method.
func (m *MockEC2API) ModifyVpnConnectionOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpnConnectionOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpnConnectionRequest mocks base method.
func (m *MockEC2API) ModifyVpnConnectionRequest(arg0 *ec2.ModifyVpnConnectionInput) (*request.Request, *ec2.ModifyVpnConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpnConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOutput)
	return ret0, ret1
}

// ModifyVpnConnectionRequest indicates an expected call of ModifyVpnConnectionRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionRequest), arg0)
}

// ModifyVpnConnectionWithContext mocks base method.
func (m *MockEC2API) ModifyVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnConnectionInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpnConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpnTunnelCertificate mocks base method.
func (m *MockEC2API) ModifyVpnTunnelCertificate(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*ec2.ModifyVpnTunnelCertificateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificate", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpnTunnelCertificate indicates an expected call of ModifyVpnTunnelCertificate.
func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificate(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificate", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificate), arg0)
}

// ModifyVpnTunnelCertificateRequest mocks base method.
func (m *MockEC2API) ModifyVpnTunnelCertificateRequest(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*request.Request, *ec2.ModifyVpnTunnelCertificateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpnTunnelCertificateOutput)
	return ret0, ret1
}

// ModifyVpnTunnelCertificateRequest indicates an expected call of ModifyVpnTunnelCertificateRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificateRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificateRequest), arg0)
}

// ModifyVpnTunnelCertificateWithContext mocks base method.
func (m *MockEC2API) ModifyVpnTunnelCertificateWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnTunnelCertificateInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelCertificateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ModifyVpnTunnelOptions mocks base method.
func (m *MockEC2API) ModifyVpnTunnelOptions(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*ec2.ModifyVpnTunnelOptionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpnTunnelOptions", arg0)
	ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVpnTunnelOptions indicates an expected call of ModifyVpnTunnelOptions.
func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptions), arg0)
}

// ModifyVpnTunnelOptionsRequest mocks base method.
func (m *MockEC2API) ModifyVpnTunnelOptionsRequest(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*request.Request, *ec2.ModifyVpnTunnelOptionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ModifyVpnTunnelOptionsOutput)
	return ret0, ret1
}

// ModifyVpnTunnelOptionsRequest indicates an expected call of ModifyVpnTunnelOptionsRequest.
func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptionsRequest), arg0)
}

// ModifyVpnTunnelOptionsWithContext mocks base method.
func (m *MockEC2API) ModifyVpnTunnelOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnTunnelOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MonitorInstances mocks base method.
func (m *MockEC2API) MonitorInstances(arg0 *ec2.MonitorInstancesInput) (*ec2.MonitorInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MonitorInstances", arg0)
	ret0, _ := ret[0].(*ec2.MonitorInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MonitorInstances indicates an expected call of MonitorInstances.
func (mr *MockEC2APIMockRecorder) MonitorInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstances", reflect.TypeOf((*MockEC2API)(nil).MonitorInstances), arg0)
}

// MonitorInstancesRequest mocks base method.
func (m *MockEC2API) MonitorInstancesRequest(arg0 *ec2.MonitorInstancesInput) (*request.Request, *ec2.MonitorInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MonitorInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.MonitorInstancesOutput)
	return ret0, ret1
}

// MonitorInstancesRequest indicates an expected call of MonitorInstancesRequest.
func (mr *MockEC2APIMockRecorder) MonitorInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).MonitorInstancesRequest), arg0)
}

// MonitorInstancesWithContext mocks base method.
func (m *MockEC2API) MonitorInstancesWithContext(arg0 context.Context, arg1 *ec2.MonitorInstancesInput, arg2 ...request.Option) (*ec2.MonitorInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MonitorInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.MonitorInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MoveAddressToVpc mocks base method.
func (m *MockEC2API) MoveAddressToVpc(arg0 *ec2.MoveAddressToVpcInput) (*ec2.MoveAddressToVpcOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MoveAddressToVpc", arg0)
	ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MoveAddressToVpc indicates an expected call of MoveAddressToVpc.
func (mr *MockEC2APIMockRecorder) MoveAddressToVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpc", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpc), arg0)
}

// MoveAddressToVpcRequest mocks base method.
func (m *MockEC2API) MoveAddressToVpcRequest(arg0 *ec2.MoveAddressToVpcInput) (*request.Request, *ec2.MoveAddressToVpcOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MoveAddressToVpcRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.MoveAddressToVpcOutput)
	return ret0, ret1
}

// MoveAddressToVpcRequest indicates an expected call of MoveAddressToVpcRequest.
func (mr *MockEC2APIMockRecorder) MoveAddressToVpcRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpcRequest", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpcRequest), arg0)
}

// MoveAddressToVpcWithContext mocks base method.
func (m *MockEC2API) MoveAddressToVpcWithContext(arg0 context.Context, arg1 *ec2.MoveAddressToVpcInput, arg2 ...request.Option) (*ec2.MoveAddressToVpcOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MoveAddressToVpcWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MoveByoipCidrToIpam mocks base method.
func (m *MockEC2API) MoveByoipCidrToIpam(arg0 *ec2.MoveByoipCidrToIpamInput) (*ec2.MoveByoipCidrToIpamOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MoveByoipCidrToIpam", arg0)
	ret0, _ := ret[0].(*ec2.MoveByoipCidrToIpamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MoveByoipCidrToIpam indicates an expected call of MoveByoipCidrToIpam.
func (mr *MockEC2APIMockRecorder) MoveByoipCidrToIpam(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveByoipCidrToIpam", reflect.TypeOf((*MockEC2API)(nil).MoveByoipCidrToIpam), arg0)
}

// MoveByoipCidrToIpamRequest mocks base method.
func (m *MockEC2API) MoveByoipCidrToIpamRequest(arg0 *ec2.MoveByoipCidrToIpamInput) (*request.Request, *ec2.MoveByoipCidrToIpamOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MoveByoipCidrToIpamRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.MoveByoipCidrToIpamOutput)
	return ret0, ret1
}

// MoveByoipCidrToIpamRequest indicates an expected call of MoveByoipCidrToIpamRequest.
func (mr *MockEC2APIMockRecorder) MoveByoipCidrToIpamRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveByoipCidrToIpamRequest", reflect.TypeOf((*MockEC2API)(nil).MoveByoipCidrToIpamRequest), arg0)
}

// MoveByoipCidrToIpamWithContext mocks base method.
func (m *MockEC2API) MoveByoipCidrToIpamWithContext(arg0 context.Context, arg1 *ec2.MoveByoipCidrToIpamInput, arg2 ...request.Option) (*ec2.MoveByoipCidrToIpamOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MoveByoipCidrToIpamWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.MoveByoipCidrToIpamOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProvisionByoipCidr mocks base method.
func (m *MockEC2API) ProvisionByoipCidr(arg0 *ec2.ProvisionByoipCidrInput) (*ec2.ProvisionByoipCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisionByoipCidr", arg0)
	ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ProvisionByoipCidr indicates an expected call of ProvisionByoipCidr.
func (mr *MockEC2APIMockRecorder) ProvisionByoipCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidr), arg0)
}

// ProvisionByoipCidrRequest mocks base method.
func (m *MockEC2API) ProvisionByoipCidrRequest(arg0 *ec2.ProvisionByoipCidrInput) (*request.Request, *ec2.ProvisionByoipCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisionByoipCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ProvisionByoipCidrOutput)
	return ret0, ret1
}

// ProvisionByoipCidrRequest indicates an expected call of ProvisionByoipCidrRequest.
func (mr *MockEC2APIMockRecorder) ProvisionByoipCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidrRequest), arg0)
}

// ProvisionByoipCidrWithContext mocks base method.
func (m *MockEC2API) ProvisionByoipCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionByoipCidrInput, arg2 ...request.Option) (*ec2.ProvisionByoipCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProvisionByoipCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProvisionIpamByoasn mocks base method.
func (m *MockEC2API) ProvisionIpamByoasn(arg0 *ec2.ProvisionIpamByoasnInput) (*ec2.ProvisionIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisionIpamByoasn", arg0)
	ret0, _ := ret[0].(*ec2.ProvisionIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ProvisionIpamByoasn indicates an expected call of ProvisionIpamByoasn.
func (mr *MockEC2APIMockRecorder) ProvisionIpamByoasn(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamByoasn", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamByoasn), arg0)
}

// ProvisionIpamByoasnRequest mocks base method.
func (m *MockEC2API) ProvisionIpamByoasnRequest(arg0 *ec2.ProvisionIpamByoasnInput) (*request.Request, *ec2.ProvisionIpamByoasnOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisionIpamByoasnRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ProvisionIpamByoasnOutput)
	return ret0, ret1
}

// ProvisionIpamByoasnRequest indicates an expected call of ProvisionIpamByoasnRequest.
func (mr *MockEC2APIMockRecorder) ProvisionIpamByoasnRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamByoasnRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamByoasnRequest), arg0)
}

// ProvisionIpamByoasnWithContext mocks base method.
func (m *MockEC2API) ProvisionIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.ProvisionIpamByoasnInput, arg2 ...request.Option) (*ec2.ProvisionIpamByoasnOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProvisionIpamByoasnWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ProvisionIpamByoasnOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProvisionIpamPoolCidr mocks base method.
func (m *MockEC2API) ProvisionIpamPoolCidr(arg0 *ec2.ProvisionIpamPoolCidrInput) (*ec2.ProvisionIpamPoolCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisionIpamPoolCidr", arg0)
	ret0, _ := ret[0].(*ec2.ProvisionIpamPoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ProvisionIpamPoolCidr indicates an expected call of ProvisionIpamPoolCidr.
func (mr *MockEC2APIMockRecorder) ProvisionIpamPoolCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamPoolCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamPoolCidr), arg0)
}

// ProvisionIpamPoolCidrRequest mocks base method.
func (m *MockEC2API) ProvisionIpamPoolCidrRequest(arg0 *ec2.ProvisionIpamPoolCidrInput) (*request.Request, *ec2.ProvisionIpamPoolCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisionIpamPoolCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ProvisionIpamPoolCidrOutput)
	return ret0, ret1
}

// ProvisionIpamPoolCidrRequest indicates an expected call of ProvisionIpamPoolCidrRequest.
func (mr *MockEC2APIMockRecorder) ProvisionIpamPoolCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamPoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionIpamPoolCidrRequest), arg0)
}

// ProvisionIpamPoolCidrWithContext mocks base method.
func (m *MockEC2API) ProvisionIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionIpamPoolCidrInput, arg2 ...request.Option) (*ec2.ProvisionIpamPoolCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProvisionIpamPoolCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ProvisionIpamPoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProvisionPublicIpv4PoolCidr mocks base method.
func (m *MockEC2API) ProvisionPublicIpv4PoolCidr(arg0 *ec2.ProvisionPublicIpv4PoolCidrInput) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidr", arg0)
	ret0, _ := ret[0].(*ec2.ProvisionPublicIpv4PoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ProvisionPublicIpv4PoolCidr indicates an expected call of ProvisionPublicIpv4PoolCidr.
func (mr *MockEC2APIMockRecorder) ProvisionPublicIpv4PoolCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionPublicIpv4PoolCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionPublicIpv4PoolCidr), arg0)
}

// ProvisionPublicIpv4PoolCidrRequest mocks base method.
func (m *MockEC2API) ProvisionPublicIpv4PoolCidrRequest(arg0 *ec2.ProvisionPublicIpv4PoolCidrInput) (*request.Request, *ec2.ProvisionPublicIpv4PoolCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ProvisionPublicIpv4PoolCidrOutput)
	return ret0, ret1
}

// ProvisionPublicIpv4PoolCidrRequest indicates an expected call of ProvisionPublicIpv4PoolCidrRequest.
func (mr *MockEC2APIMockRecorder) ProvisionPublicIpv4PoolCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionPublicIpv4PoolCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionPublicIpv4PoolCidrRequest), arg0)
}

// ProvisionPublicIpv4PoolCidrWithContext mocks base method.
func (m *MockEC2API) ProvisionPublicIpv4PoolCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionPublicIpv4PoolCidrInput, arg2 ...request.Option) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ProvisionPublicIpv4PoolCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PurchaseCapacityBlock mocks base method.
func (m *MockEC2API) PurchaseCapacityBlock(arg0 *ec2.PurchaseCapacityBlockInput) (*ec2.PurchaseCapacityBlockOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurchaseCapacityBlock", arg0)
	ret0, _ := ret[0].(*ec2.PurchaseCapacityBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurchaseCapacityBlock indicates an expected call of PurchaseCapacityBlock.
func (mr *MockEC2APIMockRecorder) PurchaseCapacityBlock(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlock", reflect.TypeOf((*MockEC2API)(nil).PurchaseCapacityBlock), arg0)
}

// PurchaseCapacityBlockRequest mocks base method.
func (m *MockEC2API) PurchaseCapacityBlockRequest(arg0 *ec2.PurchaseCapacityBlockInput) (*request.Request, *ec2.PurchaseCapacityBlockOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurchaseCapacityBlockRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.PurchaseCapacityBlockOutput)
	return ret0, ret1
}

// PurchaseCapacityBlockRequest indicates an expected call of PurchaseCapacityBlockRequest.
func (mr *MockEC2APIMockRecorder) PurchaseCapacityBlockRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlockRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseCapacityBlockRequest), arg0)
}

// PurchaseCapacityBlockWithContext mocks base method.
func (m *MockEC2API) PurchaseCapacityBlockWithContext(arg0 context.Context, arg1 *ec2.PurchaseCapacityBlockInput, arg2 ...request.Option) (*ec2.PurchaseCapacityBlockOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurchaseCapacityBlockWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.PurchaseCapacityBlockOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PurchaseHostReservation mocks base method.
func (m *MockEC2API) PurchaseHostReservation(arg0 *ec2.PurchaseHostReservationInput) (*ec2.PurchaseHostReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurchaseHostReservation", arg0)
	ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurchaseHostReservation indicates an expected call of PurchaseHostReservation.
func (mr *MockEC2APIMockRecorder) PurchaseHostReservation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservation", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservation), arg0)
}

// PurchaseHostReservationRequest mocks base method.
func (m *MockEC2API) PurchaseHostReservationRequest(arg0 *ec2.PurchaseHostReservationInput) (*request.Request, *ec2.PurchaseHostReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurchaseHostReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.PurchaseHostReservationOutput)
	return ret0, ret1
}

// PurchaseHostReservationRequest indicates an expected call of PurchaseHostReservationRequest.
func (mr *MockEC2APIMockRecorder) PurchaseHostReservationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservationRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservationRequest), arg0)
}

// PurchaseHostReservationWithContext mocks base method.
func (m *MockEC2API) PurchaseHostReservationWithContext(arg0 context.Context, arg1 *ec2.PurchaseHostReservationInput, arg2 ...request.Option) (*ec2.PurchaseHostReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurchaseHostReservationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PurchaseReservedInstancesOffering mocks base method.
func (m *MockEC2API) PurchaseReservedInstancesOffering(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*ec2.PurchaseReservedInstancesOfferingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurchaseReservedInstancesOffering", arg0)
	ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurchaseReservedInstancesOffering indicates an expected call of PurchaseReservedInstancesOffering.
func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOffering(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOffering", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOffering), arg0)
}

// PurchaseReservedInstancesOfferingRequest mocks base method.
func (m *MockEC2API) PurchaseReservedInstancesOfferingRequest(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*request.Request, *ec2.PurchaseReservedInstancesOfferingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.PurchaseReservedInstancesOfferingOutput)
	return ret0, ret1
}

// PurchaseReservedInstancesOfferingRequest indicates an expected call of PurchaseReservedInstancesOfferingRequest.
func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOfferingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOfferingRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOfferingRequest), arg0)
}

// PurchaseReservedInstancesOfferingWithContext mocks base method.
func (m *MockEC2API) PurchaseReservedInstancesOfferingWithContext(arg0 context.Context, arg1 *ec2.PurchaseReservedInstancesOfferingInput, arg2 ...request.Option) (*ec2.PurchaseReservedInstancesOfferingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PurchaseScheduledInstances mocks base method.
func (m *MockEC2API) PurchaseScheduledInstances(arg0 *ec2.PurchaseScheduledInstancesInput) (*ec2.PurchaseScheduledInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurchaseScheduledInstances", arg0)
	ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurchaseScheduledInstances indicates an expected call of PurchaseScheduledInstances.
func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstances), arg0)
}

// PurchaseScheduledInstancesRequest mocks base method.
func (m *MockEC2API) PurchaseScheduledInstancesRequest(arg0 *ec2.PurchaseScheduledInstancesInput) (*request.Request, *ec2.PurchaseScheduledInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurchaseScheduledInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.PurchaseScheduledInstancesOutput)
	return ret0, ret1
}

// PurchaseScheduledInstancesRequest indicates an expected call of PurchaseScheduledInstancesRequest.
func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstancesRequest), arg0)
}

// PurchaseScheduledInstancesWithContext mocks base method.
func (m *MockEC2API) PurchaseScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.PurchaseScheduledInstancesInput, arg2 ...request.Option) (*ec2.PurchaseScheduledInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurchaseScheduledInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RebootInstances mocks base method.
func (m *MockEC2API) RebootInstances(arg0 *ec2.RebootInstancesInput) (*ec2.RebootInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RebootInstances", arg0)
	ret0, _ := ret[0].(*ec2.RebootInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebootInstances indicates an expected call of RebootInstances.
func (mr *MockEC2APIMockRecorder) RebootInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstances", reflect.TypeOf((*MockEC2API)(nil).RebootInstances), arg0)
}

// RebootInstancesRequest mocks base method.
func (m *MockEC2API) RebootInstancesRequest(arg0 *ec2.RebootInstancesInput) (*request.Request, *ec2.RebootInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RebootInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RebootInstancesOutput)
	return ret0, ret1
}

// RebootInstancesRequest indicates an expected call of RebootInstancesRequest.
func (mr *MockEC2APIMockRecorder) RebootInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RebootInstancesRequest), arg0)
}

// RebootInstancesWithContext mocks base method.
func (m *MockEC2API) RebootInstancesWithContext(arg0 context.Context, arg1 *ec2.RebootInstancesInput, arg2 ...request.Option) (*ec2.RebootInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RebootInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RebootInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterImage mocks base method.
func (m *MockEC2API) RegisterImage(arg0 *ec2.RegisterImageInput) (*ec2.RegisterImageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterImage", arg0)
	ret0, _ := ret[0].(*ec2.RegisterImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterImage indicates an expected call of RegisterImage.
func (mr *MockEC2APIMockRecorder) RegisterImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImage", reflect.TypeOf((*MockEC2API)(nil).RegisterImage), arg0)
}

// RegisterImageRequest mocks base method.
func (m *MockEC2API) RegisterImageRequest(arg0 *ec2.RegisterImageInput) (*request.Request, *ec2.RegisterImageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterImageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RegisterImageOutput)
	return ret0, ret1
}

// RegisterImageRequest indicates an expected call of RegisterImageRequest.
func (mr *MockEC2APIMockRecorder) RegisterImageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterImageRequest), arg0)
}

// RegisterImageWithContext mocks base method.
func (m *MockEC2API) RegisterImageWithContext(arg0 context.Context, arg1 *ec2.RegisterImageInput, arg2 ...request.Option) (*ec2.RegisterImageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterImageWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RegisterImageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterInstanceEventNotificationAttributes mocks base method.
func (m *MockEC2API) RegisterInstanceEventNotificationAttributes(arg0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributes", arg0)
	ret0, _ := ret[0].(*ec2.RegisterInstanceEventNotificationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterInstanceEventNotificationAttributes indicates an expected call of RegisterInstanceEventNotificationAttributes.
func (mr *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributes), arg0)
}

// RegisterInstanceEventNotificationAttributesRequest mocks base method.
func (m *MockEC2API) RegisterInstanceEventNotificationAttributesRequest(arg0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.RegisterInstanceEventNotificationAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RegisterInstanceEventNotificationAttributesOutput)
	return ret0, ret1
}

// RegisterInstanceEventNotificationAttributesRequest indicates an expected call of RegisterInstanceEventNotificationAttributesRequest.
func (mr *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributesRequest), arg0)
}

// RegisterInstanceEventNotificationAttributesWithContext mocks base method.
func (m *MockEC2API) RegisterInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.RegisterInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RegisterInstanceEventNotificationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterTransitGatewayMulticastGroupMembers mocks base method.
func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembers(arg0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembers", arg0)
	ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterTransitGatewayMulticastGroupMembers indicates an expected call of RegisterTransitGatewayMulticastGroupMembers.
func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembers), arg0)
}

// RegisterTransitGatewayMulticastGroupMembersRequest mocks base method.
func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupMembersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
	return ret0, ret1
}

// RegisterTransitGatewayMulticastGroupMembersRequest indicates an expected call of RegisterTransitGatewayMulticastGroupMembersRequest.
func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembersRequest), arg0)
}

// RegisterTransitGatewayMulticastGroupMembersWithContext mocks base method.
func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembersWithContext(arg0 context.Context, arg1 *ec2.RegisterTransitGatewayMulticastGroupMembersInput, arg2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembersWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterTransitGatewayMulticastGroupSources mocks base method.
func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSources(arg0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSources", arg0)
	ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterTransitGatewayMulticastGroupSources indicates an expected call of RegisterTransitGatewayMulticastGroupSources.
func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSources), arg0)
}

// RegisterTransitGatewayMulticastGroupSourcesRequest mocks base method.
func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSourcesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
	return ret0, ret1
}

// RegisterTransitGatewayMulticastGroupSourcesRequest indicates an expected call of RegisterTransitGatewayMulticastGroupSourcesRequest.
func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSourcesRequest), arg0)
}

// RegisterTransitGatewayMulticastGroupSourcesWithContext mocks base method.
func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSourcesWithContext(arg0 context.Context, arg1 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, arg2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSourcesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RejectTransitGatewayMulticastDomainAssociations mocks base method.
func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociations(arg0 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociations", arg0)
	ret0, _ := ret[0].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RejectTransitGatewayMulticastDomainAssociations indicates an expected call of RejectTransitGatewayMulticastDomainAssociations.
func (mr *MockEC2APIMockRecorder) RejectTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayMulticastDomainAssociations), arg0)
}

// RejectTransitGatewayMulticastDomainAssociationsRequest mocks base method.
func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.RejectTransitGatewayMulticastDomainAssociationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
	return ret0, ret1
}

// RejectTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of RejectTransitGatewayMulticastDomainAssociationsRequest.
func (mr *MockEC2APIMockRecorder) RejectTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayMulticastDomainAssociationsRequest), arg0)
}

// RejectTransitGatewayMulticastDomainAssociationsWithContext mocks base method.
func (m *MockEC2API) RejectTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RejectTransitGatewayMulticastDomainAssociationsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RejectTransitGatewayMulticastDomainAssociationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RejectTransitGatewayPeeringAttachment mocks base method.
func (m *MockEC2API) RejectTransitGatewayPeeringAttachment(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachment", arg0)
	ret0, _ := ret[0].(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RejectTransitGatewayPeeringAttachment indicates an expected call of RejectTransitGatewayPeeringAttachment.
func (mr *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachment), arg0)
}

// RejectTransitGatewayPeeringAttachmentRequest mocks base method.
func (m *MockEC2API) RejectTransitGatewayPeeringAttachmentRequest(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayPeeringAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
	return ret0, ret1
}

// RejectTransitGatewayPeeringAttachmentRequest indicates an expected call of RejectTransitGatewayPeeringAttachmentRequest.
func (mr *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachmentRequest), arg0)
}

// RejectTransitGatewayPeeringAttachmentWithContext mocks base method.
func (m *MockEC2API) RejectTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RejectTransitGatewayPeeringAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RejectTransitGatewayVpcAttachment mocks base method.
func (m *MockEC2API) RejectTransitGatewayVpcAttachment(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachment", arg0)
	ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RejectTransitGatewayVpcAttachment indicates an expected call of RejectTransitGatewayVpcAttachment.
func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachment), arg0)
}

// RejectTransitGatewayVpcAttachmentRequest mocks base method.
func (m *MockEC2API) RejectTransitGatewayVpcAttachmentRequest(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayVpcAttachmentOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RejectTransitGatewayVpcAttachmentOutput)
	return ret0, ret1
}

// RejectTransitGatewayVpcAttachmentRequest indicates an expected call of RejectTransitGatewayVpcAttachmentRequest.
func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentRequest), arg0)
}

// RejectTransitGatewayVpcAttachmentWithContext mocks base method.
func (m *MockEC2API) RejectTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RejectVpcEndpointConnections mocks base method.
func (m *MockEC2API) RejectVpcEndpointConnections(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*ec2.RejectVpcEndpointConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectVpcEndpointConnections", arg0)
	ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RejectVpcEndpointConnections indicates an expected call of RejectVpcEndpointConnections.
func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnections(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnections), arg0)
}

// RejectVpcEndpointConnectionsRequest mocks base method.
func (m *MockEC2API) RejectVpcEndpointConnectionsRequest(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*request.Request, *ec2.RejectVpcEndpointConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RejectVpcEndpointConnectionsOutput)
	return ret0, ret1
}

// RejectVpcEndpointConnectionsRequest indicates an expected call of RejectVpcEndpointConnectionsRequest.
func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnectionsRequest), arg0)
}

// RejectVpcEndpointConnectionsWithContext mocks base method.
func (m *MockEC2API) RejectVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.RejectVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.RejectVpcEndpointConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RejectVpcPeeringConnection mocks base method.
func (m *MockEC2API) RejectVpcPeeringConnection(arg0 *ec2.RejectVpcPeeringConnectionInput) (*ec2.RejectVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectVpcPeeringConnection", arg0)
	ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RejectVpcPeeringConnection indicates an expected call of RejectVpcPeeringConnection.
func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnection), arg0)
}

// RejectVpcPeeringConnectionRequest mocks base method.
func (m *MockEC2API) RejectVpcPeeringConnectionRequest(arg0 *ec2.RejectVpcPeeringConnectionInput) (*request.Request, *ec2.RejectVpcPeeringConnectionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RejectVpcPeeringConnectionOutput)
	return ret0, ret1
}

// RejectVpcPeeringConnectionRequest indicates an expected call of RejectVpcPeeringConnectionRequest.
func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnectionRequest), arg0)
}

// RejectVpcPeeringConnectionWithContext mocks base method.
func (m *MockEC2API) RejectVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.RejectVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.RejectVpcPeeringConnectionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReleaseAddress mocks base method.
func (m *MockEC2API) ReleaseAddress(arg0 *ec2.ReleaseAddressInput) (*ec2.ReleaseAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseAddress", arg0)
	ret0, _ := ret[0].(*ec2.ReleaseAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReleaseAddress indicates an expected call of ReleaseAddress.
func (mr *MockEC2APIMockRecorder) ReleaseAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddress", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddress), arg0)
}

// ReleaseAddressRequest mocks base method.
func (m *MockEC2API) ReleaseAddressRequest(arg0 *ec2.ReleaseAddressInput) (*request.Request, *ec2.ReleaseAddressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseAddressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReleaseAddressOutput)
	return ret0, ret1
}

// ReleaseAddressRequest indicates an expected call of ReleaseAddressRequest.
func (mr *MockEC2APIMockRecorder) ReleaseAddressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddressRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddressRequest), arg0)
}

// ReleaseAddressWithContext mocks base method.
func (m *MockEC2API) ReleaseAddressWithContext(arg0 context.Context, arg1 *ec2.ReleaseAddressInput, arg2 ...request.Option) (*ec2.ReleaseAddressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReleaseAddressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReleaseAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReleaseHosts mocks base method.
func (m *MockEC2API) ReleaseHosts(arg0 *ec2.ReleaseHostsInput) (*ec2.ReleaseHostsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseHosts", arg0)
	ret0, _ := ret[0].(*ec2.ReleaseHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReleaseHosts indicates an expected call of ReleaseHosts.
func (mr *MockEC2APIMockRecorder) ReleaseHosts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHosts", reflect.TypeOf((*MockEC2API)(nil).ReleaseHosts), arg0)
}

// ReleaseHostsRequest mocks base method.
func (m *MockEC2API) ReleaseHostsRequest(arg0 *ec2.ReleaseHostsInput) (*request.Request, *ec2.ReleaseHostsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseHostsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReleaseHostsOutput)
	return ret0, ret1
}

// ReleaseHostsRequest indicates an expected call of ReleaseHostsRequest.
func (mr *MockEC2APIMockRecorder) ReleaseHostsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseHostsRequest), arg0)
}

// ReleaseHostsWithContext mocks base method.
func (m *MockEC2API) ReleaseHostsWithContext(arg0 context.Context, arg1 *ec2.ReleaseHostsInput, arg2 ...request.Option) (*ec2.ReleaseHostsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReleaseHostsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReleaseHostsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReleaseIpamPoolAllocation mocks base method.
func (m *MockEC2API) ReleaseIpamPoolAllocation(arg0 *ec2.ReleaseIpamPoolAllocationInput) (*ec2.ReleaseIpamPoolAllocationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocation", arg0)
	ret0, _ := ret[0].(*ec2.ReleaseIpamPoolAllocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReleaseIpamPoolAllocation indicates an expected call of ReleaseIpamPoolAllocation.
func (mr *MockEC2APIMockRecorder) ReleaseIpamPoolAllocation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseIpamPoolAllocation", reflect.TypeOf((*MockEC2API)(nil).ReleaseIpamPoolAllocation), arg0)
}

// ReleaseIpamPoolAllocationRequest mocks base method.
func (m *MockEC2API) ReleaseIpamPoolAllocationRequest(arg0 *ec2.ReleaseIpamPoolAllocationInput) (*request.Request, *ec2.ReleaseIpamPoolAllocationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReleaseIpamPoolAllocationOutput)
	return ret0, ret1
}

// ReleaseIpamPoolAllocationRequest indicates an expected call of ReleaseIpamPoolAllocationRequest.
func (mr *MockEC2APIMockRecorder) ReleaseIpamPoolAllocationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseIpamPoolAllocationRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseIpamPoolAllocationRequest), arg0)
}

// ReleaseIpamPoolAllocationWithContext mocks base method.
func (m *MockEC2API) ReleaseIpamPoolAllocationWithContext(arg0 context.Context, arg1 *ec2.ReleaseIpamPoolAllocationInput, arg2 ...request.Option) (*ec2.ReleaseIpamPoolAllocationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReleaseIpamPoolAllocationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceIamInstanceProfileAssociation mocks base method.
func (m *MockEC2API) ReplaceIamInstanceProfileAssociation(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociation", arg0)
	ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceIamInstanceProfileAssociation indicates an expected call of ReplaceIamInstanceProfileAssociation.
func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociation), arg0)
}

// ReplaceIamInstanceProfileAssociationRequest mocks base method.
func (m *MockEC2API) ReplaceIamInstanceProfileAssociationRequest(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*request.Request, *ec2.ReplaceIamInstanceProfileAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReplaceIamInstanceProfileAssociationOutput)
	return ret0, ret1
}

// ReplaceIamInstanceProfileAssociationRequest indicates an expected call of ReplaceIamInstanceProfileAssociationRequest.
func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationRequest), arg0)
}

// ReplaceIamInstanceProfileAssociationWithContext mocks base method.
func (m *MockEC2API) ReplaceIamInstanceProfileAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceIamInstanceProfileAssociationInput, arg2 ...request.Option) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceNetworkAclAssociation mocks base method.
func (m *MockEC2API) ReplaceNetworkAclAssociation(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*ec2.ReplaceNetworkAclAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociation", arg0)
	ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceNetworkAclAssociation indicates an expected call of ReplaceNetworkAclAssociation.
func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociation), arg0)
}

// ReplaceNetworkAclAssociationRequest mocks base method.
func (m *MockEC2API) ReplaceNetworkAclAssociationRequest(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*request.Request, *ec2.ReplaceNetworkAclAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReplaceNetworkAclAssociationOutput)
	return ret0, ret1
}

// ReplaceNetworkAclAssociationRequest indicates an expected call of ReplaceNetworkAclAssociationRequest.
func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociationRequest), arg0)
}

// ReplaceNetworkAclAssociationWithContext mocks base method.
func (m *MockEC2API) ReplaceNetworkAclAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceNetworkAclAssociationInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclAssociationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceNetworkAclEntry mocks base method.
func (m *MockEC2API) ReplaceNetworkAclEntry(arg0 *ec2.ReplaceNetworkAclEntryInput) (*ec2.ReplaceNetworkAclEntryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceNetworkAclEntry", arg0)
	ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceNetworkAclEntry indicates an expected call of ReplaceNetworkAclEntry.
func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntry(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntry), arg0)
}

// ReplaceNetworkAclEntryRequest mocks base method.
func (m *MockEC2API) ReplaceNetworkAclEntryRequest(arg0 *ec2.ReplaceNetworkAclEntryInput) (*request.Request, *ec2.ReplaceNetworkAclEntryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReplaceNetworkAclEntryOutput)
	return ret0, ret1
}

// ReplaceNetworkAclEntryRequest indicates an expected call of ReplaceNetworkAclEntryRequest.
func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntryRequest), arg0)
}

// ReplaceNetworkAclEntryWithContext mocks base method.
func (m *MockEC2API) ReplaceNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.ReplaceNetworkAclEntryInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclEntryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceRoute mocks base method.
func (m *MockEC2API) ReplaceRoute(arg0 *ec2.ReplaceRouteInput) (*ec2.ReplaceRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceRoute", arg0)
	ret0, _ := ret[0].(*ec2.ReplaceRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceRoute indicates an expected call of ReplaceRoute.
func (mr *MockEC2APIMockRecorder) ReplaceRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceRoute), arg0)
}

// ReplaceRouteRequest mocks base method.
func (m *MockEC2API) ReplaceRouteRequest(arg0 *ec2.ReplaceRouteInput) (*request.Request, *ec2.ReplaceRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReplaceRouteOutput)
	return ret0, ret1
}

// ReplaceRouteRequest indicates an expected call of ReplaceRouteRequest.
func (mr *MockEC2APIMockRecorder) ReplaceRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteRequest), arg0)
}

// ReplaceRouteTableAssociation mocks base method.
func (m *MockEC2API) ReplaceRouteTableAssociation(arg0 *ec2.ReplaceRouteTableAssociationInput) (*ec2.ReplaceRouteTableAssociationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceRouteTableAssociation", arg0)
	ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceRouteTableAssociation indicates an expected call of ReplaceRouteTableAssociation.
func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociation), arg0)
}

// ReplaceRouteTableAssociationRequest mocks base method.
func (m *MockEC2API) ReplaceRouteTableAssociationRequest(arg0 *ec2.ReplaceRouteTableAssociationInput) (*request.Request, *ec2.ReplaceRouteTableAssociationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReplaceRouteTableAssociationOutput)
	return ret0, ret1
}

// ReplaceRouteTableAssociationRequest indicates an expected call of ReplaceRouteTableAssociationRequest.
func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociationRequest), arg0)
}

// ReplaceRouteTableAssociationWithContext mocks base method.
func (m *MockEC2API) ReplaceRouteTableAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceRouteTableAssociationInput, arg2 ...request.Option) (*ec2.ReplaceRouteTableAssociationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceRouteWithContext mocks base method.
func (m *MockEC2API) ReplaceRouteWithContext(arg0 context.Context, arg1 *ec2.ReplaceRouteInput, arg2 ...request.Option) (*ec2.ReplaceRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReplaceRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceTransitGatewayRoute mocks base method.
func (m *MockEC2API) ReplaceTransitGatewayRoute(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*ec2.ReplaceTransitGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceTransitGatewayRoute", arg0)
	ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceTransitGatewayRoute indicates an expected call of ReplaceTransitGatewayRoute.
func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRoute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRoute), arg0)
}

// ReplaceTransitGatewayRouteRequest mocks base method.
func (m *MockEC2API) ReplaceTransitGatewayRouteRequest(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*request.Request, *ec2.ReplaceTransitGatewayRouteOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReplaceTransitGatewayRouteOutput)
	return ret0, ret1
}

// ReplaceTransitGatewayRouteRequest indicates an expected call of ReplaceTransitGatewayRouteRequest.
func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteRequest), arg0)
}

// ReplaceTransitGatewayRouteWithContext mocks base method.
func (m *MockEC2API) ReplaceTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.ReplaceTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.ReplaceTransitGatewayRouteOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceVpnTunnel mocks base method.
func (m *MockEC2API) ReplaceVpnTunnel(arg0 *ec2.ReplaceVpnTunnelInput) (*ec2.ReplaceVpnTunnelOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceVpnTunnel", arg0)
	ret0, _ := ret[0].(*ec2.ReplaceVpnTunnelOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceVpnTunnel indicates an expected call of ReplaceVpnTunnel.
func (mr *MockEC2APIMockRecorder) ReplaceVpnTunnel(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceVpnTunnel", reflect.TypeOf((*MockEC2API)(nil).ReplaceVpnTunnel), arg0)
}

// ReplaceVpnTunnelRequest mocks base method.
func (m *MockEC2API) ReplaceVpnTunnelRequest(arg0 *ec2.ReplaceVpnTunnelInput) (*request.Request, *ec2.ReplaceVpnTunnelOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceVpnTunnelRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReplaceVpnTunnelOutput)
	return ret0, ret1
}

// ReplaceVpnTunnelRequest indicates an expected call of ReplaceVpnTunnelRequest.
func (mr *MockEC2APIMockRecorder) ReplaceVpnTunnelRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceVpnTunnelRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceVpnTunnelRequest), arg0)
}

// ReplaceVpnTunnelWithContext mocks base method.
func (m *MockEC2API) ReplaceVpnTunnelWithContext(arg0 context.Context, arg1 *ec2.ReplaceVpnTunnelInput, arg2 ...request.Option) (*ec2.ReplaceVpnTunnelOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceVpnTunnelWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReplaceVpnTunnelOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReportInstanceStatus mocks base method.
func (m *MockEC2API) ReportInstanceStatus(arg0 *ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReportInstanceStatus", arg0)
	ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReportInstanceStatus indicates an expected call of ReportInstanceStatus.
func (mr *MockEC2APIMockRecorder) ReportInstanceStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatus), arg0)
}

// ReportInstanceStatusRequest mocks base method.
func (m *MockEC2API) ReportInstanceStatusRequest(arg0 *ec2.ReportInstanceStatusInput) (*request.Request, *ec2.ReportInstanceStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReportInstanceStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ReportInstanceStatusOutput)
	return ret0, ret1
}

// ReportInstanceStatusRequest indicates an expected call of ReportInstanceStatusRequest.
func (mr *MockEC2APIMockRecorder) ReportInstanceStatusRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatusRequest), arg0)
}

// ReportInstanceStatusWithContext mocks base method.
func (m *MockEC2API) ReportInstanceStatusWithContext(arg0 context.Context, arg1 *ec2.ReportInstanceStatusInput, arg2 ...request.Option) (*ec2.ReportInstanceStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReportInstanceStatusWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RequestSpotFleet mocks base method.
func (m *MockEC2API) RequestSpotFleet(arg0 *ec2.RequestSpotFleetInput) (*ec2.RequestSpotFleetOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestSpotFleet", arg0)
	ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RequestSpotFleet indicates an expected call of RequestSpotFleet.
func (mr *MockEC2APIMockRecorder) RequestSpotFleet(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleet", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleet), arg0)
}

// RequestSpotFleetRequest mocks base method.
func (m *MockEC2API) RequestSpotFleetRequest(arg0 *ec2.RequestSpotFleetInput) (*request.Request, *ec2.RequestSpotFleetOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestSpotFleetRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RequestSpotFleetOutput)
	return ret0, ret1
}

// RequestSpotFleetRequest indicates an expected call of RequestSpotFleetRequest.
func (mr *MockEC2APIMockRecorder) RequestSpotFleetRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleetRequest), arg0)
}

// RequestSpotFleetWithContext mocks base method.
func (m *MockEC2API) RequestSpotFleetWithContext(arg0 context.Context, arg1 *ec2.RequestSpotFleetInput, arg2 ...request.Option) (*ec2.RequestSpotFleetOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RequestSpotFleetWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RequestSpotInstances mocks base method.
func (m *MockEC2API) RequestSpotInstances(arg0 *ec2.RequestSpotInstancesInput) (*ec2.RequestSpotInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestSpotInstances", arg0)
	ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RequestSpotInstances indicates an expected call of RequestSpotInstances.
func (mr *MockEC2APIMockRecorder) RequestSpotInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstances", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstances), arg0)
}

// RequestSpotInstancesRequest mocks base method.
func (m *MockEC2API) RequestSpotInstancesRequest(arg0 *ec2.RequestSpotInstancesInput) (*request.Request, *ec2.RequestSpotInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestSpotInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RequestSpotInstancesOutput)
	return ret0, ret1
}

// RequestSpotInstancesRequest indicates an expected call of RequestSpotInstancesRequest.
func (mr *MockEC2APIMockRecorder) RequestSpotInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesRequest), arg0)
}

// RequestSpotInstancesWithContext mocks base method.
func (m *MockEC2API) RequestSpotInstancesWithContext(arg0 context.Context, arg1 *ec2.RequestSpotInstancesInput, arg2 ...request.Option) (*ec2.RequestSpotInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RequestSpotInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResetAddressAttribute mocks base method.
func (m *MockEC2API) ResetAddressAttribute(arg0 *ec2.ResetAddressAttributeInput) (*ec2.ResetAddressAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetAddressAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ResetAddressAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetAddressAttribute indicates an expected call of ResetAddressAttribute.
func (mr *MockEC2APIMockRecorder) ResetAddressAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetAddressAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetAddressAttribute), arg0)
}

// ResetAddressAttributeRequest mocks base method.
func (m *MockEC2API) ResetAddressAttributeRequest(arg0 *ec2.ResetAddressAttributeInput) (*request.Request, *ec2.ResetAddressAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetAddressAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ResetAddressAttributeOutput)
	return ret0, ret1
}

// ResetAddressAttributeRequest indicates an expected call of ResetAddressAttributeRequest.
func (mr *MockEC2APIMockRecorder) ResetAddressAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetAddressAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetAddressAttributeRequest), arg0)
}

// ResetAddressAttributeWithContext mocks base method.
func (m *MockEC2API) ResetAddressAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetAddressAttributeInput, arg2 ...request.Option) (*ec2.ResetAddressAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetAddressAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ResetAddressAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResetEbsDefaultKmsKeyId mocks base method.
func (m *MockEC2API) ResetEbsDefaultKmsKeyId(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyId", arg0)
	ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetEbsDefaultKmsKeyId indicates an expected call of ResetEbsDefaultKmsKeyId.
func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyId), arg0)
}

// ResetEbsDefaultKmsKeyIdRequest mocks base method.
func (m *MockEC2API) ResetEbsDefaultKmsKeyIdRequest(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ResetEbsDefaultKmsKeyIdOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ResetEbsDefaultKmsKeyIdOutput)
	return ret0, ret1
}

// ResetEbsDefaultKmsKeyIdRequest indicates an expected call of ResetEbsDefaultKmsKeyIdRequest.
func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdRequest), arg0)
}

// ResetEbsDefaultKmsKeyIdWithContext mocks base method.
func (m *MockEC2API) ResetEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.ResetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResetFpgaImageAttribute mocks base method.
func (m *MockEC2API) ResetFpgaImageAttribute(arg0 *ec2.ResetFpgaImageAttributeInput) (*ec2.ResetFpgaImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetFpgaImageAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetFpgaImageAttribute indicates an expected call of ResetFpgaImageAttribute.
func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttribute), arg0)
}

// ResetFpgaImageAttributeRequest mocks base method.
func (m *MockEC2API) ResetFpgaImageAttributeRequest(arg0 *ec2.ResetFpgaImageAttributeInput) (*request.Request, *ec2.ResetFpgaImageAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetFpgaImageAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ResetFpgaImageAttributeOutput)
	return ret0, ret1
}

// ResetFpgaImageAttributeRequest indicates an expected call of ResetFpgaImageAttributeRequest.
func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttributeRequest), arg0)
}

// ResetFpgaImageAttributeWithContext mocks base method.
func (m *MockEC2API) ResetFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ResetFpgaImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetFpgaImageAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResetImageAttribute mocks base method.
func (m *MockEC2API) ResetImageAttribute(arg0 *ec2.ResetImageAttributeInput) (*ec2.ResetImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetImageAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetImageAttribute indicates an expected call of ResetImageAttribute.
func (mr *MockEC2APIMockRecorder) ResetImageAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttribute), arg0)
}

// ResetImageAttributeRequest mocks base method.
func (m *MockEC2API) ResetImageAttributeRequest(arg0 *ec2.ResetImageAttributeInput) (*request.Request, *ec2.ResetImageAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetImageAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ResetImageAttributeOutput)
	return ret0, ret1
}

// ResetImageAttributeRequest indicates an expected call of ResetImageAttributeRequest.
func (mr *MockEC2APIMockRecorder) ResetImageAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttributeRequest), arg0)
}

// ResetImageAttributeWithContext mocks base method.
func (m *MockEC2API) ResetImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetImageAttributeInput, arg2 ...request.Option) (*ec2.ResetImageAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetImageAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResetInstanceAttribute mocks base method.
func (m *MockEC2API) ResetInstanceAttribute(arg0 *ec2.ResetInstanceAttributeInput) (*ec2.ResetInstanceAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetInstanceAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetInstanceAttribute indicates an expected call of ResetInstanceAttribute.
func (mr *MockEC2APIMockRecorder) ResetInstanceAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttribute), arg0)
}

// ResetInstanceAttributeRequest mocks base method.
func (m *MockEC2API) ResetInstanceAttributeRequest(arg0 *ec2.ResetInstanceAttributeInput) (*request.Request, *ec2.ResetInstanceAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetInstanceAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ResetInstanceAttributeOutput)
	return ret0, ret1
}

// ResetInstanceAttributeRequest indicates an expected call of ResetInstanceAttributeRequest.
func (mr *MockEC2APIMockRecorder) ResetInstanceAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttributeRequest), arg0)
}

// ResetInstanceAttributeWithContext mocks base method.
func (m *MockEC2API) ResetInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetInstanceAttributeInput, arg2 ...request.Option) (*ec2.ResetInstanceAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetInstanceAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResetNetworkInterfaceAttribute mocks base method.
func (m *MockEC2API) ResetNetworkInterfaceAttribute(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*ec2.ResetNetworkInterfaceAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetNetworkInterfaceAttribute indicates an expected call of ResetNetworkInterfaceAttribute.
func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttribute), arg0)
}

// ResetNetworkInterfaceAttributeRequest mocks base method.
func (m *MockEC2API) ResetNetworkInterfaceAttributeRequest(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*request.Request, *ec2.ResetNetworkInterfaceAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ResetNetworkInterfaceAttributeOutput)
	return ret0, ret1
}

// ResetNetworkInterfaceAttributeRequest indicates an expected call of ResetNetworkInterfaceAttributeRequest.
func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttributeRequest), arg0)
}

// ResetNetworkInterfaceAttributeWithContext mocks base method.
func (m *MockEC2API) ResetNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ResetNetworkInterfaceAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResetSnapshotAttribute mocks base method.
func (m *MockEC2API) ResetSnapshotAttribute(arg0 *ec2.ResetSnapshotAttributeInput) (*ec2.ResetSnapshotAttributeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetSnapshotAttribute", arg0)
	ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetSnapshotAttribute indicates an expected call of ResetSnapshotAttribute.
func (mr *MockEC2APIMockRecorder) ResetSnapshotAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttribute), arg0)
}

// ResetSnapshotAttributeRequest mocks base method.
func (m *MockEC2API) ResetSnapshotAttributeRequest(arg0 *ec2.ResetSnapshotAttributeInput) (*request.Request, *ec2.ResetSnapshotAttributeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetSnapshotAttributeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.ResetSnapshotAttributeOutput)
	return ret0, ret1
}

// ResetSnapshotAttributeRequest indicates an expected call of ResetSnapshotAttributeRequest.
func (mr *MockEC2APIMockRecorder) ResetSnapshotAttributeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttributeRequest), arg0)
}

// ResetSnapshotAttributeWithContext mocks base method.
func (m *MockEC2API) ResetSnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetSnapshotAttributeInput, arg2 ...request.Option) (*ec2.ResetSnapshotAttributeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetSnapshotAttributeWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreAddressToClassic mocks base method.
func (m *MockEC2API) RestoreAddressToClassic(arg0 *ec2.RestoreAddressToClassicInput) (*ec2.RestoreAddressToClassicOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreAddressToClassic", arg0)
	ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreAddressToClassic indicates an expected call of RestoreAddressToClassic.
func (mr *MockEC2APIMockRecorder) RestoreAddressToClassic(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassic", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassic), arg0)
}

// RestoreAddressToClassicRequest mocks base method.
func (m *MockEC2API) RestoreAddressToClassicRequest(arg0 *ec2.RestoreAddressToClassicInput) (*request.Request, *ec2.RestoreAddressToClassicOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreAddressToClassicRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RestoreAddressToClassicOutput)
	return ret0, ret1
}

// RestoreAddressToClassicRequest indicates an expected call of RestoreAddressToClassicRequest.
func (mr *MockEC2APIMockRecorder) RestoreAddressToClassicRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassicRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassicRequest), arg0)
}

// RestoreAddressToClassicWithContext mocks base method.
func (m *MockEC2API) RestoreAddressToClassicWithContext(arg0 context.Context, arg1 *ec2.RestoreAddressToClassicInput, arg2 ...request.Option) (*ec2.RestoreAddressToClassicOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreAddressToClassicWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreImageFromRecycleBin mocks base method.
func (m *MockEC2API) RestoreImageFromRecycleBin(arg0 *ec2.RestoreImageFromRecycleBinInput) (*ec2.RestoreImageFromRecycleBinOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreImageFromRecycleBin", arg0)
	ret0, _ := ret[0].(*ec2.RestoreImageFromRecycleBinOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreImageFromRecycleBin indicates an expected call of RestoreImageFromRecycleBin.
func (mr *MockEC2APIMockRecorder) RestoreImageFromRecycleBin(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreImageFromRecycleBin", reflect.TypeOf((*MockEC2API)(nil).RestoreImageFromRecycleBin), arg0)
}

// RestoreImageFromRecycleBinRequest mocks base method.
func (m *MockEC2API) RestoreImageFromRecycleBinRequest(arg0 *ec2.RestoreImageFromRecycleBinInput) (*request.Request, *ec2.RestoreImageFromRecycleBinOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreImageFromRecycleBinRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RestoreImageFromRecycleBinOutput)
	return ret0, ret1
}

// RestoreImageFromRecycleBinRequest indicates an expected call of RestoreImageFromRecycleBinRequest.
func (mr *MockEC2APIMockRecorder) RestoreImageFromRecycleBinRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreImageFromRecycleBinRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreImageFromRecycleBinRequest), arg0)
}

// RestoreImageFromRecycleBinWithContext mocks base method.
func (m *MockEC2API) RestoreImageFromRecycleBinWithContext(arg0 context.Context, arg1 *ec2.RestoreImageFromRecycleBinInput, arg2 ...request.Option) (*ec2.RestoreImageFromRecycleBinOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreImageFromRecycleBinWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RestoreImageFromRecycleBinOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreManagedPrefixListVersion mocks base method.
func (m *MockEC2API) RestoreManagedPrefixListVersion(arg0 *ec2.RestoreManagedPrefixListVersionInput) (*ec2.RestoreManagedPrefixListVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersion", arg0)
	ret0, _ := ret[0].(*ec2.RestoreManagedPrefixListVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreManagedPrefixListVersion indicates an expected call of RestoreManagedPrefixListVersion.
func (mr *MockEC2APIMockRecorder) RestoreManagedPrefixListVersion(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersion", reflect.TypeOf((*MockEC2API)(nil).RestoreManagedPrefixListVersion), arg0)
}

// RestoreManagedPrefixListVersionRequest mocks base method.
func (m *MockEC2API) RestoreManagedPrefixListVersionRequest(arg0 *ec2.RestoreManagedPrefixListVersionInput) (*request.Request, *ec2.RestoreManagedPrefixListVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RestoreManagedPrefixListVersionOutput)
	return ret0, ret1
}

// RestoreManagedPrefixListVersionRequest indicates an expected call of RestoreManagedPrefixListVersionRequest.
func (mr *MockEC2APIMockRecorder) RestoreManagedPrefixListVersionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersionRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreManagedPrefixListVersionRequest), arg0)
}

// RestoreManagedPrefixListVersionWithContext mocks base method.
func (m *MockEC2API) RestoreManagedPrefixListVersionWithContext(arg0 context.Context, arg1 *ec2.RestoreManagedPrefixListVersionInput, arg2 ...request.Option) (*ec2.RestoreManagedPrefixListVersionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersionWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RestoreManagedPrefixListVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreSnapshotFromRecycleBin mocks base method.
func (m *MockEC2API) RestoreSnapshotFromRecycleBin(arg0 *ec2.RestoreSnapshotFromRecycleBinInput) (*ec2.RestoreSnapshotFromRecycleBinOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBin", arg0)
	ret0, _ := ret[0].(*ec2.RestoreSnapshotFromRecycleBinOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreSnapshotFromRecycleBin indicates an expected call of RestoreSnapshotFromRecycleBin.
func (mr *MockEC2APIMockRecorder) RestoreSnapshotFromRecycleBin(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotFromRecycleBin", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotFromRecycleBin), arg0)
}

// RestoreSnapshotFromRecycleBinRequest mocks base method.
func (m *MockEC2API) RestoreSnapshotFromRecycleBinRequest(arg0 *ec2.RestoreSnapshotFromRecycleBinInput) (*request.Request, *ec2.RestoreSnapshotFromRecycleBinOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBinRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RestoreSnapshotFromRecycleBinOutput)
	return ret0, ret1
}

// RestoreSnapshotFromRecycleBinRequest indicates an expected call of RestoreSnapshotFromRecycleBinRequest.
func (mr *MockEC2APIMockRecorder) RestoreSnapshotFromRecycleBinRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotFromRecycleBinRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotFromRecycleBinRequest), arg0)
}

// RestoreSnapshotFromRecycleBinWithContext mocks base method.
func (m *MockEC2API) RestoreSnapshotFromRecycleBinWithContext(arg0 context.Context, arg1 *ec2.RestoreSnapshotFromRecycleBinInput, arg2 ...request.Option) (*ec2.RestoreSnapshotFromRecycleBinOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBinWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RestoreSnapshotFromRecycleBinOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreSnapshotTier mocks base method.
func (m *MockEC2API) RestoreSnapshotTier(arg0 *ec2.RestoreSnapshotTierInput) (*ec2.RestoreSnapshotTierOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreSnapshotTier", arg0)
	ret0, _ := ret[0].(*ec2.RestoreSnapshotTierOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreSnapshotTier indicates an expected call of RestoreSnapshotTier.
func (mr *MockEC2APIMockRecorder) RestoreSnapshotTier(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotTier", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotTier), arg0)
}

// RestoreSnapshotTierRequest mocks base method.
func (m *MockEC2API) RestoreSnapshotTierRequest(arg0 *ec2.RestoreSnapshotTierInput) (*request.Request, *ec2.RestoreSnapshotTierOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreSnapshotTierRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RestoreSnapshotTierOutput)
	return ret0, ret1
}

// RestoreSnapshotTierRequest indicates an expected call of RestoreSnapshotTierRequest.
func (mr *MockEC2APIMockRecorder) RestoreSnapshotTierRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotTierRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreSnapshotTierRequest), arg0)
}

// RestoreSnapshotTierWithContext mocks base method.
func (m *MockEC2API) RestoreSnapshotTierWithContext(arg0 context.Context, arg1 *ec2.RestoreSnapshotTierInput, arg2 ...request.Option) (*ec2.RestoreSnapshotTierOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreSnapshotTierWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RestoreSnapshotTierOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RevokeClientVpnIngress mocks base method.
func (m *MockEC2API) RevokeClientVpnIngress(arg0 *ec2.RevokeClientVpnIngressInput) (*ec2.RevokeClientVpnIngressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeClientVpnIngress", arg0)
	ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeClientVpnIngress indicates an expected call of RevokeClientVpnIngress.
func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngress), arg0)
}

// RevokeClientVpnIngressRequest mocks base method.
func (m *MockEC2API) RevokeClientVpnIngressRequest(arg0 *ec2.RevokeClientVpnIngressInput) (*request.Request, *ec2.RevokeClientVpnIngressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeClientVpnIngressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RevokeClientVpnIngressOutput)
	return ret0, ret1
}

// RevokeClientVpnIngressRequest indicates an expected call of RevokeClientVpnIngressRequest.
func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngressRequest), arg0)
}

// RevokeClientVpnIngressWithContext mocks base method.
func (m *MockEC2API) RevokeClientVpnIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeClientVpnIngressInput, arg2 ...request.Option) (*ec2.RevokeClientVpnIngressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevokeClientVpnIngressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RevokeSecurityGroupEgress mocks base method.
func (m *MockEC2API) RevokeSecurityGroupEgress(arg0 *ec2.RevokeSecurityGroupEgressInput) (*ec2.RevokeSecurityGroupEgressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeSecurityGroupEgress", arg0)
	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeSecurityGroupEgress indicates an expected call of RevokeSecurityGroupEgress.
func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgress), arg0)
}

// RevokeSecurityGroupEgressRequest mocks base method.
func (m *MockEC2API) RevokeSecurityGroupEgressRequest(arg0 *ec2.RevokeSecurityGroupEgressInput) (*request.Request, *ec2.RevokeSecurityGroupEgressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RevokeSecurityGroupEgressOutput)
	return ret0, ret1
}

// RevokeSecurityGroupEgressRequest indicates an expected call of RevokeSecurityGroupEgressRequest.
func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgressRequest), arg0)
}

// RevokeSecurityGroupEgressWithContext mocks base method.
func (m *MockEC2API) RevokeSecurityGroupEgressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupEgressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RevokeSecurityGroupIngress mocks base method.
func (m *MockEC2API) RevokeSecurityGroupIngress(arg0 *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeSecurityGroupIngress", arg0)
	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeSecurityGroupIngress indicates an expected call of RevokeSecurityGroupIngress.
func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngress), arg0)
}

// RevokeSecurityGroupIngressRequest mocks base method.
func (m *MockEC2API) RevokeSecurityGroupIngressRequest(arg0 *ec2.RevokeSecurityGroupIngressInput) (*request.Request, *ec2.RevokeSecurityGroupIngressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RevokeSecurityGroupIngressOutput)
	return ret0, ret1
}

// RevokeSecurityGroupIngressRequest indicates an expected call of RevokeSecurityGroupIngressRequest.
func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngressRequest), arg0)
}

// RevokeSecurityGroupIngressWithContext mocks base method.
func (m *MockEC2API) RevokeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupIngressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RunInstances mocks base method.
func (m *MockEC2API) RunInstances(arg0 *ec2.RunInstancesInput) (*ec2.Reservation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunInstances", arg0)
	ret0, _ := ret[0].(*ec2.Reservation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunInstances indicates an expected call of RunInstances.
func (mr *MockEC2APIMockRecorder) RunInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstances", reflect.TypeOf((*MockEC2API)(nil).RunInstances), arg0)
}

// RunInstancesRequest mocks base method.
func (m *MockEC2API) RunInstancesRequest(arg0 *ec2.RunInstancesInput) (*request.Request, *ec2.Reservation) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.Reservation)
	return ret0, ret1
}

// RunInstancesRequest indicates an expected call of RunInstancesRequest.
func (mr *MockEC2APIMockRecorder) RunInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunInstancesRequest), arg0)
}

// RunInstancesWithContext mocks base method.
func (m *MockEC2API) RunInstancesWithContext(arg0 context.Context, arg1 *ec2.RunInstancesInput, arg2 ...request.Option) (*ec2.Reservation, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.Reservation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RunScheduledInstances mocks base method.
func (m *MockEC2API) RunScheduledInstances(arg0 *ec2.RunScheduledInstancesInput) (*ec2.RunScheduledInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunScheduledInstances", arg0)
	ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunScheduledInstances indicates an expected call of RunScheduledInstances.
func (mr *MockEC2APIMockRecorder) RunScheduledInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstances), arg0)
}

// RunScheduledInstancesRequest mocks base method.
func (m *MockEC2API) RunScheduledInstancesRequest(arg0 *ec2.RunScheduledInstancesInput) (*request.Request, *ec2.RunScheduledInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunScheduledInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.RunScheduledInstancesOutput)
	return ret0, ret1
}

// RunScheduledInstancesRequest indicates an expected call of RunScheduledInstancesRequest.
func (mr *MockEC2APIMockRecorder) RunScheduledInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstancesRequest), arg0)
}

// RunScheduledInstancesWithContext mocks base method.
func (m *MockEC2API) RunScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.RunScheduledInstancesInput, arg2 ...request.Option) (*ec2.RunScheduledInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunScheduledInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchLocalGatewayRoutes mocks base method.
func (m *MockEC2API) SearchLocalGatewayRoutes(arg0 *ec2.SearchLocalGatewayRoutesInput) (*ec2.SearchLocalGatewayRoutesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutes", arg0)
	ret0, _ := ret[0].(*ec2.SearchLocalGatewayRoutesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchLocalGatewayRoutes indicates an expected call of SearchLocalGatewayRoutes.
func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutes), arg0)
}

// SearchLocalGatewayRoutesPages mocks base method.
func (m *MockEC2API) SearchLocalGatewayRoutesPages(arg0 *ec2.SearchLocalGatewayRoutesInput, arg1 func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SearchLocalGatewayRoutesPages indicates an expected call of SearchLocalGatewayRoutesPages.
func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesPages", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesPages), arg0, arg1)
}

// SearchLocalGatewayRoutesPagesWithContext mocks base method.
func (m *MockEC2API) SearchLocalGatewayRoutesPagesWithContext(arg0 context.Context, arg1 *ec2.SearchLocalGatewayRoutesInput, arg2 func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchLocalGatewayRoutesRequest mocks base method.
func (m *MockEC2API) SearchLocalGatewayRoutesRequest(arg0 *ec2.SearchLocalGatewayRoutesInput) (*request.Request, *ec2.SearchLocalGatewayRoutesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.SearchLocalGatewayRoutesOutput)
	return ret0, ret1
}

// SearchLocalGatewayRoutesRequest indicates an expected call of SearchLocalGatewayRoutesRequest.
func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesRequest), arg0)
}

// SearchLocalGatewayRoutesWithContext mocks base method.
func (m *MockEC2API) SearchLocalGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.SearchLocalGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchLocalGatewayRoutesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.SearchLocalGatewayRoutesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchTransitGatewayMulticastGroups mocks base method.
func (m *MockEC2API) SearchTransitGatewayMulticastGroups(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroups", arg0)
	ret0, _ := ret[0].(*ec2.SearchTransitGatewayMulticastGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchTransitGatewayMulticastGroups indicates an expected call of SearchTransitGatewayMulticastGroups.
func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroups", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroups), arg0)
}

// SearchTransitGatewayMulticastGroupsPages mocks base method.
func (m *MockEC2API) SearchTransitGatewayMulticastGroupsPages(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput, arg1 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SearchTransitGatewayMulticastGroupsPages indicates an expected call of SearchTransitGatewayMulticastGroupsPages.
func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsPages", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsPages), arg0, arg1)
}

// SearchTransitGatewayMulticastGroupsPagesWithContext mocks base method.
func (m *MockEC2API) SearchTransitGatewayMulticastGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayMulticastGroupsInput, arg2 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SearchTransitGatewayMulticastGroupsRequest mocks base method.
func (m *MockEC2API) SearchTransitGatewayMulticastGroupsRequest(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*request.Request, *ec2.SearchTransitGatewayMulticastGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.SearchTransitGatewayMulticastGroupsOutput)
	return ret0, ret1
}

// SearchTransitGatewayMulticastGroupsRequest indicates an expected call of SearchTransitGatewayMulticastGroupsRequest.
func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsRequest), arg0)
}

// SearchTransitGatewayMulticastGroupsWithContext mocks base method.
func (m *MockEC2API) SearchTransitGatewayMulticastGroupsWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayMulticastGroupsInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.SearchTransitGatewayMulticastGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchTransitGatewayRoutes mocks base method.
func (m *MockEC2API) SearchTransitGatewayRoutes(arg0 *ec2.SearchTransitGatewayRoutesInput) (*ec2.SearchTransitGatewayRoutesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchTransitGatewayRoutes", arg0)
	ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchTransitGatewayRoutes indicates an expected call of SearchTransitGatewayRoutes.
func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutes), arg0)
}

// SearchTransitGatewayRoutesRequest mocks base method.
func (m *MockEC2API) SearchTransitGatewayRoutesRequest(arg0 *ec2.SearchTransitGatewayRoutesInput) (*request.Request, *ec2.SearchTransitGatewayRoutesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.SearchTransitGatewayRoutesOutput)
	return ret0, ret1
}

// SearchTransitGatewayRoutesRequest indicates an expected call of SearchTransitGatewayRoutesRequest.
func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutesRequest), arg0)
}

// SearchTransitGatewayRoutesWithContext mocks base method.
func (m *MockEC2API) SearchTransitGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayRoutesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendDiagnosticInterrupt mocks base method.
func (m *MockEC2API) SendDiagnosticInterrupt(arg0 *ec2.SendDiagnosticInterruptInput) (*ec2.SendDiagnosticInterruptOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendDiagnosticInterrupt", arg0)
	ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendDiagnosticInterrupt indicates an expected call of SendDiagnosticInterrupt.
func (mr *MockEC2APIMockRecorder) SendDiagnosticInterrupt(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterrupt", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterrupt), arg0)
}

// SendDiagnosticInterruptRequest mocks base method.
func (m *MockEC2API) SendDiagnosticInterruptRequest(arg0 *ec2.SendDiagnosticInterruptInput) (*request.Request, *ec2.SendDiagnosticInterruptOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendDiagnosticInterruptRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.SendDiagnosticInterruptOutput)
	return ret0, ret1
}

// SendDiagnosticInterruptRequest indicates an expected call of SendDiagnosticInterruptRequest.
func (mr *MockEC2APIMockRecorder) SendDiagnosticInterruptRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterruptRequest", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterruptRequest), arg0)
}

// SendDiagnosticInterruptWithContext mocks base method.
func (m *MockEC2API) SendDiagnosticInterruptWithContext(arg0 context.Context, arg1 *ec2.SendDiagnosticInterruptInput, arg2 ...request.Option) (*ec2.SendDiagnosticInterruptOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendDiagnosticInterruptWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartInstances mocks base method.
func (m *MockEC2API) StartInstances(arg0 *ec2.StartInstancesInput) (*ec2.StartInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartInstances", arg0)
	ret0, _ := ret[0].(*ec2.StartInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartInstances indicates an expected call of StartInstances.
func (mr *MockEC2APIMockRecorder) StartInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstances", reflect.TypeOf((*MockEC2API)(nil).StartInstances), arg0)
}

// StartInstancesRequest mocks base method.
func (m *MockEC2API) StartInstancesRequest(arg0 *ec2.StartInstancesInput) (*request.Request, *ec2.StartInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.StartInstancesOutput)
	return ret0, ret1
}

// StartInstancesRequest indicates an expected call of StartInstancesRequest.
func (mr *MockEC2APIMockRecorder) StartInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StartInstancesRequest), arg0)
}

// StartInstancesWithContext mocks base method.
func (m *MockEC2API) StartInstancesWithContext(arg0 context.Context, arg1 *ec2.StartInstancesInput, arg2 ...request.Option) (*ec2.StartInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.StartInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartNetworkInsightsAccessScopeAnalysis mocks base method.
func (m *MockEC2API) StartNetworkInsightsAccessScopeAnalysis(arg0 *ec2.StartNetworkInsightsAccessScopeAnalysisInput) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysis", arg0)
	ret0, _ := ret[0].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartNetworkInsightsAccessScopeAnalysis indicates an expected call of StartNetworkInsightsAccessScopeAnalysis.
func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAccessScopeAnalysis(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAccessScopeAnalysis", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAccessScopeAnalysis), arg0)
}

// StartNetworkInsightsAccessScopeAnalysisRequest mocks base method.
func (m *MockEC2API) StartNetworkInsightsAccessScopeAnalysisRequest(arg0 *ec2.StartNetworkInsightsAccessScopeAnalysisInput) (*request.Request, *ec2.StartNetworkInsightsAccessScopeAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput)
	return ret0, ret1
}

// StartNetworkInsightsAccessScopeAnalysisRequest indicates an expected call of StartNetworkInsightsAccessScopeAnalysisRequest.
func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAccessScopeAnalysisRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAccessScopeAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAccessScopeAnalysisRequest), arg0)
}

// StartNetworkInsightsAccessScopeAnalysisWithContext mocks base method.
func (m *MockEC2API) StartNetworkInsightsAccessScopeAnalysisWithContext(arg0 context.Context, arg1 *ec2.StartNetworkInsightsAccessScopeAnalysisInput, arg2 ...request.Option) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartNetworkInsightsAnalysis mocks base method.
func (m *MockEC2API) StartNetworkInsightsAnalysis(arg0 *ec2.StartNetworkInsightsAnalysisInput) (*ec2.StartNetworkInsightsAnalysisOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysis", arg0)
	ret0, _ := ret[0].(*ec2.StartNetworkInsightsAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartNetworkInsightsAnalysis indicates an expected call of StartNetworkInsightsAnalysis.
func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAnalysis(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAnalysis", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAnalysis), arg0)
}

// StartNetworkInsightsAnalysisRequest mocks base method.
func (m *MockEC2API) StartNetworkInsightsAnalysisRequest(arg0 *ec2.StartNetworkInsightsAnalysisInput) (*request.Request, *ec2.StartNetworkInsightsAnalysisOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysisRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.StartNetworkInsightsAnalysisOutput)
	return ret0, ret1
}

// StartNetworkInsightsAnalysisRequest indicates an expected call of StartNetworkInsightsAnalysisRequest.
func (mr *MockEC2APIMockRecorder) StartNetworkInsightsAnalysisRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAnalysisRequest", reflect.TypeOf((*MockEC2API)(nil).StartNetworkInsightsAnalysisRequest), arg0)
}

// StartNetworkInsightsAnalysisWithContext mocks base method.
func (m *MockEC2API) StartNetworkInsightsAnalysisWithContext(arg0 context.Context, arg1 *ec2.StartNetworkInsightsAnalysisInput, arg2 ...request.Option) (*ec2.StartNetworkInsightsAnalysisOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartNetworkInsightsAnalysisWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.StartNetworkInsightsAnalysisOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartVpcEndpointServicePrivateDnsVerification mocks base method.
func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerification(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerification", arg0)
	ret0, _ := ret[0].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartVpcEndpointServicePrivateDnsVerification indicates an expected call of StartVpcEndpointServicePrivateDnsVerification.
func (mr *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerification(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerification", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerification), arg0)
}

// StartVpcEndpointServicePrivateDnsVerificationRequest mocks base method.
func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*request.Request, *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerificationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
	return ret0, ret1
}

// StartVpcEndpointServicePrivateDnsVerificationRequest indicates an expected call of StartVpcEndpointServicePrivateDnsVerificationRequest.
func (mr *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerificationRequest", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerificationRequest), arg0)
}

// StartVpcEndpointServicePrivateDnsVerificationWithContext mocks base method.
func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerificationWithContext(arg0 context.Context, arg1 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, arg2 ...request.Option) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerificationWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopInstances mocks base method.
func (m *MockEC2API) StopInstances(arg0 *ec2.StopInstancesInput) (*ec2.StopInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopInstances", arg0)
	ret0, _ := ret[0].(*ec2.StopInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopInstances indicates an expected call of StopInstances.
func (mr *MockEC2APIMockRecorder) StopInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstances", reflect.TypeOf((*MockEC2API)(nil).StopInstances), arg0)
}

// StopInstancesRequest mocks base method.
func (m *MockEC2API) StopInstancesRequest(arg0 *ec2.StopInstancesInput) (*request.Request, *ec2.StopInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.StopInstancesOutput)
	return ret0, ret1
}

// StopInstancesRequest indicates an expected call of StopInstancesRequest.
func (mr *MockEC2APIMockRecorder) StopInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StopInstancesRequest), arg0)
}

// StopInstancesWithContext mocks base method.
func (m *MockEC2API) StopInstancesWithContext(arg0 context.Context, arg1 *ec2.StopInstancesInput, arg2 ...request.Option) (*ec2.StopInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.StopInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TerminateClientVpnConnections mocks base method.
func (m *MockEC2API) TerminateClientVpnConnections(arg0 *ec2.TerminateClientVpnConnectionsInput) (*ec2.TerminateClientVpnConnectionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TerminateClientVpnConnections", arg0)
	ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TerminateClientVpnConnections indicates an expected call of TerminateClientVpnConnections.
func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnections(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnections), arg0)
}

// TerminateClientVpnConnectionsRequest mocks base method.
func (m *MockEC2API) TerminateClientVpnConnectionsRequest(arg0 *ec2.TerminateClientVpnConnectionsInput) (*request.Request, *ec2.TerminateClientVpnConnectionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.TerminateClientVpnConnectionsOutput)
	return ret0, ret1
}

// TerminateClientVpnConnectionsRequest indicates an expected call of TerminateClientVpnConnectionsRequest.
func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnectionsRequest), arg0)
}

// TerminateClientVpnConnectionsWithContext mocks base method.
func (m *MockEC2API) TerminateClientVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.TerminateClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.TerminateClientVpnConnectionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TerminateInstances mocks base method.
func (m *MockEC2API) TerminateInstances(arg0 *ec2.TerminateInstancesInput) (*ec2.TerminateInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TerminateInstances", arg0)
	ret0, _ := ret[0].(*ec2.TerminateInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TerminateInstances indicates an expected call of TerminateInstances.
func (mr *MockEC2APIMockRecorder) TerminateInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstances", reflect.TypeOf((*MockEC2API)(nil).TerminateInstances), arg0)
}

// TerminateInstancesRequest mocks base method.
func (m *MockEC2API) TerminateInstancesRequest(arg0 *ec2.TerminateInstancesInput) (*request.Request, *ec2.TerminateInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TerminateInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.TerminateInstancesOutput)
	return ret0, ret1
}

// TerminateInstancesRequest indicates an expected call of TerminateInstancesRequest.
func (mr *MockEC2APIMockRecorder) TerminateInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateInstancesRequest), arg0)
}

// TerminateInstancesWithContext mocks base method.
func (m *MockEC2API) TerminateInstancesWithContext(arg0 context.Context, arg1 *ec2.TerminateInstancesInput, arg2 ...request.Option) (*ec2.TerminateInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TerminateInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.TerminateInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnassignIpv6Addresses mocks base method.
func (m *MockEC2API) UnassignIpv6Addresses(arg0 *ec2.UnassignIpv6AddressesInput) (*ec2.UnassignIpv6AddressesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnassignIpv6Addresses", arg0)
	ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnassignIpv6Addresses indicates an expected call of UnassignIpv6Addresses.
func (mr *MockEC2APIMockRecorder) UnassignIpv6Addresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6Addresses), arg0)
}

// UnassignIpv6AddressesRequest mocks base method.
func (m *MockEC2API) UnassignIpv6AddressesRequest(arg0 *ec2.UnassignIpv6AddressesInput) (*request.Request, *ec2.UnassignIpv6AddressesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnassignIpv6AddressesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.UnassignIpv6AddressesOutput)
	return ret0, ret1
}

// UnassignIpv6AddressesRequest indicates an expected call of UnassignIpv6AddressesRequest.
func (mr *MockEC2APIMockRecorder) UnassignIpv6AddressesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6AddressesRequest), arg0)
}

// UnassignIpv6AddressesWithContext mocks base method.
func (m *MockEC2API) UnassignIpv6AddressesWithContext(arg0 context.Context, arg1 *ec2.UnassignIpv6AddressesInput, arg2 ...request.Option) (*ec2.UnassignIpv6AddressesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnassignIpv6AddressesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnassignPrivateIpAddresses mocks base method.
func (m *MockEC2API) UnassignPrivateIpAddresses(arg0 *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnassignPrivateIpAddresses", arg0)
	ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnassignPrivateIpAddresses indicates an expected call of UnassignPrivateIpAddresses.
func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddresses), arg0)
}

// UnassignPrivateIpAddressesRequest mocks base method.
func (m *MockEC2API) UnassignPrivateIpAddressesRequest(arg0 *ec2.UnassignPrivateIpAddressesInput) (*request.Request, *ec2.UnassignPrivateIpAddressesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.UnassignPrivateIpAddressesOutput)
	return ret0, ret1
}

// UnassignPrivateIpAddressesRequest indicates an expected call of UnassignPrivateIpAddressesRequest.
func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesRequest), arg0)
}

// UnassignPrivateIpAddressesWithContext mocks base method.
func (m *MockEC2API) UnassignPrivateIpAddressesWithContext(arg0 context.Context, arg1 *ec2.UnassignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.UnassignPrivateIpAddressesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnassignPrivateNatGatewayAddress mocks base method.
func (m *MockEC2API) UnassignPrivateNatGatewayAddress(arg0 *ec2.UnassignPrivateNatGatewayAddressInput) (*ec2.UnassignPrivateNatGatewayAddressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddress", arg0)
	ret0, _ := ret[0].(*ec2.UnassignPrivateNatGatewayAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnassignPrivateNatGatewayAddress indicates an expected call of UnassignPrivateNatGatewayAddress.
func (mr *MockEC2APIMockRecorder) UnassignPrivateNatGatewayAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateNatGatewayAddress", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateNatGatewayAddress), arg0)
}

// UnassignPrivateNatGatewayAddressRequest mocks base method.
func (m *MockEC2API) UnassignPrivateNatGatewayAddressRequest(arg0 *ec2.UnassignPrivateNatGatewayAddressInput) (*request.Request, *ec2.UnassignPrivateNatGatewayAddressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.UnassignPrivateNatGatewayAddressOutput)
	return ret0, ret1
}

// UnassignPrivateNatGatewayAddressRequest indicates an expected call of UnassignPrivateNatGatewayAddressRequest.
func (mr *MockEC2APIMockRecorder) UnassignPrivateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateNatGatewayAddressRequest), arg0)
}

// UnassignPrivateNatGatewayAddressWithContext mocks base method.
func (m *MockEC2API) UnassignPrivateNatGatewayAddressWithContext(arg0 context.Context, arg1 *ec2.UnassignPrivateNatGatewayAddressInput, arg2 ...request.Option) (*ec2.UnassignPrivateNatGatewayAddressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnassignPrivateNatGatewayAddressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.UnassignPrivateNatGatewayAddressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnlockSnapshot mocks base method.
func (m *MockEC2API) UnlockSnapshot(arg0 *ec2.UnlockSnapshotInput) (*ec2.UnlockSnapshotOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnlockSnapshot", arg0)
	ret0, _ := ret[0].(*ec2.UnlockSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnlockSnapshot indicates an expected call of UnlockSnapshot.
func (mr *MockEC2APIMockRecorder) UnlockSnapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockSnapshot", reflect.TypeOf((*MockEC2API)(nil).UnlockSnapshot), arg0)
}

// UnlockSnapshotRequest mocks base method.
func (m *MockEC2API) UnlockSnapshotRequest(arg0 *ec2.UnlockSnapshotInput) (*request.Request, *ec2.UnlockSnapshotOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnlockSnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.UnlockSnapshotOutput)
	return ret0, ret1
}

// UnlockSnapshotRequest indicates an expected call of UnlockSnapshotRequest.
func (mr *MockEC2APIMockRecorder) UnlockSnapshotRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).UnlockSnapshotRequest), arg0)
}

// UnlockSnapshotWithContext mocks base method.
func (m *MockEC2API) UnlockSnapshotWithContext(arg0 context.Context, arg1 *ec2.UnlockSnapshotInput, arg2 ...request.Option) (*ec2.UnlockSnapshotOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnlockSnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.UnlockSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnmonitorInstances mocks base method.
func (m *MockEC2API) UnmonitorInstances(arg0 *ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnmonitorInstances", arg0)
	ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnmonitorInstances indicates an expected call of UnmonitorInstances.
func (mr *MockEC2APIMockRecorder) UnmonitorInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstances", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstances), arg0)
}

// UnmonitorInstancesRequest mocks base method.
func (m *MockEC2API) UnmonitorInstancesRequest(arg0 *ec2.UnmonitorInstancesInput) (*request.Request, *ec2.UnmonitorInstancesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnmonitorInstancesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.UnmonitorInstancesOutput)
	return ret0, ret1
}

// UnmonitorInstancesRequest indicates an expected call of UnmonitorInstancesRequest.
func (mr *MockEC2APIMockRecorder) UnmonitorInstancesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstancesRequest), arg0)
}

// UnmonitorInstancesWithContext mocks base method.
func (m *MockEC2API) UnmonitorInstancesWithContext(arg0 context.Context, arg1 *ec2.UnmonitorInstancesInput, arg2 ...request.Option) (*ec2.UnmonitorInstancesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnmonitorInstancesWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateSecurityGroupRuleDescriptionsEgress mocks base method.
func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgress", arg0)
	ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSecurityGroupRuleDescriptionsEgress indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgress.
func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgress), arg0)
}

// UpdateSecurityGroupRuleDescriptionsEgressRequest mocks base method.
func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
	return ret0, ret1
}

// UpdateSecurityGroupRuleDescriptionsEgressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressRequest.
func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressRequest), arg0)
}

// UpdateSecurityGroupRuleDescriptionsEgressWithContext mocks base method.
func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressWithContext(arg0 context.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateSecurityGroupRuleDescriptionsIngress mocks base method.
func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngress", arg0)
	ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSecurityGroupRuleDescriptionsIngress indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngress.
func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngress), arg0)
}

// UpdateSecurityGroupRuleDescriptionsIngressRequest mocks base method.
func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
	return ret0, ret1
}

// UpdateSecurityGroupRuleDescriptionsIngressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressRequest.
func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressRequest), arg0)
}

// UpdateSecurityGroupRuleDescriptionsIngressWithContext mocks base method.
func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressWithContext(arg0 context.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WaitUntilBundleTaskComplete mocks base method.
func (m *MockEC2API) WaitUntilBundleTaskComplete(arg0 *ec2.DescribeBundleTasksInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilBundleTaskComplete", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilBundleTaskComplete indicates an expected call of WaitUntilBundleTaskComplete.
func (mr *MockEC2APIMockRecorder) WaitUntilBundleTaskComplete(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBundleTaskComplete", reflect.TypeOf((*MockEC2API)(nil).WaitUntilBundleTaskComplete), arg0)
}

// WaitUntilBundleTaskCompleteWithContext mocks base method.
func (m *MockEC2API) WaitUntilBundleTaskCompleteWithContext(arg0 context.Context, arg1 *ec2.DescribeBundleTasksInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilBundleTaskCompleteWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilConversionTaskCancelled mocks base method.
func (m *MockEC2API) WaitUntilConversionTaskCancelled(arg0 *ec2.DescribeConversionTasksInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilConversionTaskCancelled", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilConversionTaskCancelled indicates an expected call of WaitUntilConversionTaskCancelled.
func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCancelled(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCancelled), arg0)
}

// WaitUntilConversionTaskCancelledWithContext mocks base method.
func (m *MockEC2API) WaitUntilConversionTaskCancelledWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilConversionTaskCancelledWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilConversionTaskCompleted mocks base method.
func (m *MockEC2API) WaitUntilConversionTaskCompleted(arg0 *ec2.DescribeConversionTasksInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilConversionTaskCompleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilConversionTaskCompleted indicates an expected call of WaitUntilConversionTaskCompleted.
func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCompleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCompleted), arg0)
}

// WaitUntilConversionTaskCompletedWithContext mocks base method.
func (m *MockEC2API) WaitUntilConversionTaskCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilConversionTaskCompletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilConversionTaskDeleted mocks base method.
func (m *MockEC2API) WaitUntilConversionTaskDeleted(arg0 *ec2.DescribeConversionTasksInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilConversionTaskDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilConversionTaskDeleted indicates an expected call of WaitUntilConversionTaskDeleted.
func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskDeleted), arg0)
}

// WaitUntilConversionTaskDeletedWithContext mocks base method.
func (m *MockEC2API) WaitUntilConversionTaskDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilConversionTaskDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilCustomerGatewayAvailable mocks base method.
func (m *MockEC2API) WaitUntilCustomerGatewayAvailable(arg0 *ec2.DescribeCustomerGatewaysInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilCustomerGatewayAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilCustomerGatewayAvailable indicates an expected call of WaitUntilCustomerGatewayAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilCustomerGatewayAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCustomerGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailable), arg0)
}

// WaitUntilCustomerGatewayAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilCustomerGatewayAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilCustomerGatewayAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilExportTaskCancelled mocks base method.
func (m *MockEC2API) WaitUntilExportTaskCancelled(arg0 *ec2.DescribeExportTasksInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilExportTaskCancelled", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilExportTaskCancelled indicates an expected call of WaitUntilExportTaskCancelled.
func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCancelled(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCancelled), arg0)
}

// WaitUntilExportTaskCancelledWithContext mocks base method.
func (m *MockEC2API) WaitUntilExportTaskCancelledWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilExportTaskCancelledWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilExportTaskCompleted mocks base method.
func (m *MockEC2API) WaitUntilExportTaskCompleted(arg0 *ec2.DescribeExportTasksInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilExportTaskCompleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilExportTaskCompleted indicates an expected call of WaitUntilExportTaskCompleted.
func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCompleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCompleted), arg0)
}

// WaitUntilExportTaskCompletedWithContext mocks base method.
func (m *MockEC2API) WaitUntilExportTaskCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilExportTaskCompletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilImageAvailable mocks base method.
func (m *MockEC2API) WaitUntilImageAvailable(arg0 *ec2.DescribeImagesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilImageAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageAvailable indicates an expected call of WaitUntilImageAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilImageAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageAvailable), arg0)
}

// WaitUntilImageAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilImageAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilImageAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilImageExists mocks base method.
func (m *MockEC2API) WaitUntilImageExists(arg0 *ec2.DescribeImagesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilImageExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilImageExists indicates an expected call of WaitUntilImageExists.
func (mr *MockEC2APIMockRecorder) WaitUntilImageExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageExists), arg0)
}

// WaitUntilImageExistsWithContext mocks base method.
func (m *MockEC2API) WaitUntilImageExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilImageExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilInstanceExists mocks base method.
func (m *MockEC2API) WaitUntilInstanceExists(arg0 *ec2.DescribeInstancesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilInstanceExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilInstanceExists indicates an expected call of WaitUntilInstanceExists.
func (mr *MockEC2APIMockRecorder) WaitUntilInstanceExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceExists), arg0)
}

// WaitUntilInstanceExistsWithContext mocks base method.
func (m *MockEC2API) WaitUntilInstanceExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilInstanceExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilInstanceRunning mocks base method.
func (m *MockEC2API) WaitUntilInstanceRunning(arg0 *ec2.DescribeInstancesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilInstanceRunning", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilInstanceRunning indicates an expected call of WaitUntilInstanceRunning.
func (mr *MockEC2APIMockRecorder) WaitUntilInstanceRunning(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceRunning", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceRunning), arg0)
}

// WaitUntilInstanceRunningWithContext mocks base method.
func (m *MockEC2API) WaitUntilInstanceRunningWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilInstanceRunningWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilInstanceStatusOk mocks base method.
func (m *MockEC2API) WaitUntilInstanceStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilInstanceStatusOk", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilInstanceStatusOk indicates an expected call of WaitUntilInstanceStatusOk.
func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStatusOk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStatusOk), arg0)
}

// WaitUntilInstanceStatusOkWithContext mocks base method.
func (m *MockEC2API) WaitUntilInstanceStatusOkWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilInstanceStatusOkWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilInstanceStopped mocks base method.
func (m *MockEC2API) WaitUntilInstanceStopped(arg0 *ec2.DescribeInstancesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilInstanceStopped", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilInstanceStopped indicates an expected call of WaitUntilInstanceStopped.
func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStopped(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStopped", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStopped), arg0)
}

// WaitUntilInstanceStoppedWithContext mocks base method.
func (m *MockEC2API) WaitUntilInstanceStoppedWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilInstanceStoppedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilInstanceTerminated mocks base method.
func (m *MockEC2API) WaitUntilInstanceTerminated(arg0 *ec2.DescribeInstancesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilInstanceTerminated", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilInstanceTerminated indicates an expected call of WaitUntilInstanceTerminated.
func (mr *MockEC2APIMockRecorder) WaitUntilInstanceTerminated(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceTerminated", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceTerminated), arg0)
}

// WaitUntilInstanceTerminatedWithContext mocks base method.
func (m *MockEC2API) WaitUntilInstanceTerminatedWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilInstanceTerminatedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilInternetGatewayExists mocks base method.
func (m *MockEC2API) WaitUntilInternetGatewayExists(arg0 *ec2.DescribeInternetGatewaysInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilInternetGatewayExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilInternetGatewayExists indicates an expected call of WaitUntilInternetGatewayExists.
func (mr *MockEC2APIMockRecorder) WaitUntilInternetGatewayExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInternetGatewayExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInternetGatewayExists), arg0)
}

// WaitUntilInternetGatewayExistsWithContext mocks base method.
func (m *MockEC2API) WaitUntilInternetGatewayExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilInternetGatewayExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilKeyPairExists mocks base method.
func (m *MockEC2API) WaitUntilKeyPairExists(arg0 *ec2.DescribeKeyPairsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilKeyPairExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilKeyPairExists indicates an expected call of WaitUntilKeyPairExists.
func (mr *MockEC2APIMockRecorder) WaitUntilKeyPairExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilKeyPairExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilKeyPairExists), arg0)
}

// WaitUntilKeyPairExistsWithContext mocks base method.
func (m *MockEC2API) WaitUntilKeyPairExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeKeyPairsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilKeyPairExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilNatGatewayAvailable mocks base method.
func (m *MockEC2API) WaitUntilNatGatewayAvailable(arg0 *ec2.DescribeNatGatewaysInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilNatGatewayAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNatGatewayAvailable indicates an expected call of WaitUntilNatGatewayAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayAvailable), arg0)
}

// WaitUntilNatGatewayAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilNatGatewayAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilNatGatewayAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilNatGatewayDeleted mocks base method.
func (m *MockEC2API) WaitUntilNatGatewayDeleted(arg0 *ec2.DescribeNatGatewaysInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilNatGatewayDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNatGatewayDeleted indicates an expected call of WaitUntilNatGatewayDeleted.
func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayDeleted), arg0)
}

// WaitUntilNatGatewayDeletedWithContext mocks base method.
func (m *MockEC2API) WaitUntilNatGatewayDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilNatGatewayDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilNetworkInterfaceAvailable mocks base method.
func (m *MockEC2API) WaitUntilNetworkInterfaceAvailable(arg0 *ec2.DescribeNetworkInterfacesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilNetworkInterfaceAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilNetworkInterfaceAvailable indicates an expected call of WaitUntilNetworkInterfaceAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilNetworkInterfaceAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNetworkInterfaceAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailable), arg0)
}

// WaitUntilNetworkInterfaceAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilNetworkInterfaceAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilNetworkInterfaceAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilPasswordDataAvailable mocks base method.
func (m *MockEC2API) WaitUntilPasswordDataAvailable(arg0 *ec2.GetPasswordDataInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilPasswordDataAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilPasswordDataAvailable indicates an expected call of WaitUntilPasswordDataAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilPasswordDataAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPasswordDataAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilPasswordDataAvailable), arg0)
}

// WaitUntilPasswordDataAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilPasswordDataAvailableWithContext(arg0 context.Context, arg1 *ec2.GetPasswordDataInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilPasswordDataAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilSecurityGroupExists mocks base method.
func (m *MockEC2API) WaitUntilSecurityGroupExists(arg0 *ec2.DescribeSecurityGroupsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilSecurityGroupExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilSecurityGroupExists indicates an expected call of WaitUntilSecurityGroupExists.
func (mr *MockEC2APIMockRecorder) WaitUntilSecurityGroupExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSecurityGroupExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSecurityGroupExists), arg0)
}

// WaitUntilSecurityGroupExistsWithContext mocks base method.
func (m *MockEC2API) WaitUntilSecurityGroupExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilSecurityGroupExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilSnapshotCompleted mocks base method.
func (m *MockEC2API) WaitUntilSnapshotCompleted(arg0 *ec2.DescribeSnapshotsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilSnapshotCompleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilSnapshotCompleted indicates an expected call of WaitUntilSnapshotCompleted.
func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotCompleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompleted), arg0)
}

// WaitUntilSnapshotCompletedWithContext mocks base method.
func (m *MockEC2API) WaitUntilSnapshotCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilSnapshotCompletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilSnapshotImported mocks base method.
func (m *MockEC2API) WaitUntilSnapshotImported(arg0 *ec2.DescribeImportSnapshotTasksInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilSnapshotImported", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilSnapshotImported indicates an expected call of WaitUntilSnapshotImported.
func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotImported(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotImported", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotImported), arg0)
}

// WaitUntilSnapshotImportedWithContext mocks base method.
func (m *MockEC2API) WaitUntilSnapshotImportedWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilSnapshotImportedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilSpotInstanceRequestFulfilled mocks base method.
func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilled(arg0 *ec2.DescribeSpotInstanceRequestsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilSpotInstanceRequestFulfilled", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilSpotInstanceRequestFulfilled indicates an expected call of WaitUntilSpotInstanceRequestFulfilled.
func (mr *MockEC2APIMockRecorder) WaitUntilSpotInstanceRequestFulfilled(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSpotInstanceRequestFulfilled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilled), arg0)
}

// WaitUntilSpotInstanceRequestFulfilledWithContext mocks base method.
func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilledWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilSpotInstanceRequestFulfilledWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilStoreImageTaskComplete mocks base method.
func (m *MockEC2API) WaitUntilStoreImageTaskComplete(arg0 *ec2.DescribeStoreImageTasksInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilStoreImageTaskComplete", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilStoreImageTaskComplete indicates an expected call of WaitUntilStoreImageTaskComplete.
func (mr *MockEC2APIMockRecorder) WaitUntilStoreImageTaskComplete(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStoreImageTaskComplete", reflect.TypeOf((*MockEC2API)(nil).WaitUntilStoreImageTaskComplete), arg0)
}

// WaitUntilStoreImageTaskCompleteWithContext mocks base method.
func (m *MockEC2API) WaitUntilStoreImageTaskCompleteWithContext(arg0 context.Context, arg1 *ec2.DescribeStoreImageTasksInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilStoreImageTaskCompleteWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilSubnetAvailable mocks base method.
func (m *MockEC2API) WaitUntilSubnetAvailable(arg0 *ec2.DescribeSubnetsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilSubnetAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilSubnetAvailable indicates an expected call of WaitUntilSubnetAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilSubnetAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSubnetAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSubnetAvailable), arg0)
}

// WaitUntilSubnetAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilSubnetAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilSubnetAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilSystemStatusOk mocks base method.
func (m *MockEC2API) WaitUntilSystemStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilSystemStatusOk", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilSystemStatusOk indicates an expected call of WaitUntilSystemStatusOk.
func (mr *MockEC2APIMockRecorder) WaitUntilSystemStatusOk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSystemStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSystemStatusOk), arg0)
}

// WaitUntilSystemStatusOkWithContext mocks base method.
func (m *MockEC2API) WaitUntilSystemStatusOkWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilSystemStatusOkWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilVolumeAvailable mocks base method.
func (m *MockEC2API) WaitUntilVolumeAvailable(arg0 *ec2.DescribeVolumesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVolumeAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVolumeAvailable indicates an expected call of WaitUntilVolumeAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilVolumeAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeAvailable), arg0)
}

// WaitUntilVolumeAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilVolumeAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVolumeAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilVolumeDeleted mocks base method.
func (m *MockEC2API) WaitUntilVolumeDeleted(arg0 *ec2.DescribeVolumesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVolumeDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVolumeDeleted indicates an expected call of WaitUntilVolumeDeleted.
func (mr *MockEC2APIMockRecorder) WaitUntilVolumeDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeDeleted), arg0)
}

// WaitUntilVolumeDeletedWithContext mocks base method.
func (m *MockEC2API) WaitUntilVolumeDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVolumeDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilVolumeInUse mocks base method.
func (m *MockEC2API) WaitUntilVolumeInUse(arg0 *ec2.DescribeVolumesInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVolumeInUse", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVolumeInUse indicates an expected call of WaitUntilVolumeInUse.
func (mr *MockEC2APIMockRecorder) WaitUntilVolumeInUse(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeInUse", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeInUse), arg0)
}

// WaitUntilVolumeInUseWithContext mocks base method.
func (m *MockEC2API) WaitUntilVolumeInUseWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVolumeInUseWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilVpcAvailable mocks base method.
func (m *MockEC2API) WaitUntilVpcAvailable(arg0 *ec2.DescribeVpcsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVpcAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVpcAvailable indicates an expected call of WaitUntilVpcAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilVpcAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcAvailable), arg0)
}

// WaitUntilVpcAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilVpcAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVpcAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilVpcExists mocks base method.
func (m *MockEC2API) WaitUntilVpcExists(arg0 *ec2.DescribeVpcsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVpcExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVpcExists indicates an expected call of WaitUntilVpcExists.
func (mr *MockEC2APIMockRecorder) WaitUntilVpcExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcExists), arg0)
}

// WaitUntilVpcExistsWithContext mocks base method.
func (m *MockEC2API) WaitUntilVpcExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVpcExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilVpcPeeringConnectionDeleted mocks base method.
func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeleted(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVpcPeeringConnectionDeleted indicates an expected call of WaitUntilVpcPeeringConnectionDeleted.
func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeleted), arg0)
}

// WaitUntilVpcPeeringConnectionDeletedWithContext mocks base method.
func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilVpcPeeringConnectionExists mocks base method.
func (m *MockEC2API) WaitUntilVpcPeeringConnectionExists(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVpcPeeringConnectionExists indicates an expected call of WaitUntilVpcPeeringConnectionExists.
func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExists), arg0)
}

// WaitUntilVpcPeeringConnectionExistsWithContext mocks base method.
func (m *MockEC2API) WaitUntilVpcPeeringConnectionExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilVpnConnectionAvailable mocks base method.
func (m *MockEC2API) WaitUntilVpnConnectionAvailable(arg0 *ec2.DescribeVpnConnectionsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVpnConnectionAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVpnConnectionAvailable indicates an expected call of WaitUntilVpnConnectionAvailable.
func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailable), arg0)
}

// WaitUntilVpnConnectionAvailableWithContext mocks base method.
func (m *MockEC2API) WaitUntilVpnConnectionAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVpnConnectionAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVpnConnectionAvailableWithContext indicates an expected call of WaitUntilVpnConnectionAvailableWithContext.
func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailableWithContext), varargs...)
}

// WaitUntilVpnConnectionDeleted mocks base method.
func (m *MockEC2API) WaitUntilVpnConnectionDeleted(arg0 *ec2.DescribeVpnConnectionsInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilVpnConnectionDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVpnConnectionDeleted indicates an expected call of WaitUntilVpnConnectionDeleted.
func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeleted(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeleted), arg0)
}

// WaitUntilVpnConnectionDeletedWithContext mocks base method.
func (m *MockEC2API) WaitUntilVpnConnectionDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilVpnConnectionDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilVpnConnectionDeletedWithContext indicates an expected call of WaitUntilVpnConnectionDeletedWithContext.
func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeletedWithContext), varargs...)
}

// WithdrawByoipCidr mocks base method.
func (m *MockEC2API) WithdrawByoipCidr(arg0 *ec2.WithdrawByoipCidrInput) (*ec2.WithdrawByoipCidrOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithdrawByoipCidr", arg0)
	ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WithdrawByoipCidr indicates an expected call of WithdrawByoipCidr.
func (mr *MockEC2APIMockRecorder) WithdrawByoipCidr(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidr", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidr), arg0)
}

// WithdrawByoipCidrRequest mocks base method.
func (m *MockEC2API) WithdrawByoipCidrRequest(arg0 *ec2.WithdrawByoipCidrInput) (*request.Request, *ec2.WithdrawByoipCidrOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithdrawByoipCidrRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*ec2.WithdrawByoipCidrOutput)
	return ret0, ret1
}

// WithdrawByoipCidrRequest indicates an expected call of WithdrawByoipCidrRequest.
func (mr *MockEC2APIMockRecorder) WithdrawByoipCidrRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrRequest), arg0)
}

// WithdrawByoipCidrWithContext mocks base method.
func (m *MockEC2API) WithdrawByoipCidrWithContext(arg0 context.Context, arg1 *ec2.WithdrawByoipCidrInput, arg2 ...request.Option) (*ec2.WithdrawByoipCidrOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WithdrawByoipCidrWithContext", varargs...)
	ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WithdrawByoipCidrWithContext indicates an expected call of WithdrawByoipCidrWithContext.
func (mr *MockEC2APIMockRecorder) WithdrawByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrWithContext), varargs...)
}
