diff between older EC2API.go and newer EC2API.go for cloud-nuke

EC2API-go.diff

$ diff EC2API.go /var/tmp/newer-EC2API.go


388,437d387
< // 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)
< }
< 
< // ApplySecurityGroupsToClientVpnTargetNetworkWithContext mocks base method
< func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
588,637d537
< // 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)
< }
< 
< // AssociateClientVpnTargetNetworkWithContext mocks base method
< func (m *MockEC2API) AssociateClientVpnTargetNetworkWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
1188,1237d1087
< // 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)
< }
< 
< // AuthorizeClientVpnIngressWithContext mocks base method
< func (m *MockEC2API) AuthorizeClientVpnIngressWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
2038,2137d1887
< // 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)
< }
< 
< // CreateClientVpnEndpointWithContext mocks base method
< func (m *MockEC2API) CreateClientVpnEndpointWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // CreateClientVpnRouteWithContext mocks base method
< func (m *MockEC2API) CreateClientVpnRouteWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
3388,3437d3137
< // 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)
< }
< 
< // CreateSnapshotsWithContext mocks base method
< func (m *MockEC2API) CreateSnapshotsWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
3588,3589c3288,3289
< // CreateTrafficMirrorFilter mocks base method
< func (m *MockEC2API) CreateTrafficMirrorFilter(arg0 *ec2.CreateTrafficMirrorFilterInput) (*ec2.CreateTrafficMirrorFilterOutput, error) {
---
> // CreateTransitGateway mocks base method
> func (m *MockEC2API) CreateTransitGateway(arg0 *ec2.CreateTransitGatewayInput) (*ec2.CreateTransitGatewayOutput, error) {
3591,3592c3291,3292
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilter", arg0)
< 	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGateway", arg0)
> 	ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput)
3597,3598c3297,3298
< // CreateTrafficMirrorFilter indicates an expected call of CreateTrafficMirrorFilter
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilter(arg0 interface{}) *gomock.Call {
---
> // CreateTransitGateway indicates an expected call of CreateTransitGateway
> func (mr *MockEC2APIMockRecorder) CreateTransitGateway(arg0 interface{}) *gomock.Call {
3600c3300
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilter), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGateway", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGateway), arg0)
3603,3604c3303,3304
< // CreateTrafficMirrorFilterWithContext mocks base method
< func (m *MockEC2API) CreateTrafficMirrorFilterWithContext(arg0 aws.Context, arg1 *ec2.CreateTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterOutput, error) {
---
> // CreateTransitGatewayWithContext mocks base method
> func (m *MockEC2API) CreateTransitGatewayWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayOutput, error) {
3610,3611c3310,3311
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterWithContext", varargs...)
< 	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayWithContext", varargs...)
> 	ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput)
3616,3617c3316,3317
< // CreateTrafficMirrorFilterWithContext indicates an expected call of CreateTrafficMirrorFilterWithContext
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
---
> // CreateTransitGatewayWithContext indicates an expected call of CreateTransitGatewayWithContext
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
3620c3320
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayWithContext), varargs...)
3623,3624c3323,3324
< // CreateTrafficMirrorFilterRequest mocks base method
< func (m *MockEC2API) CreateTrafficMirrorFilterRequest(arg0 *ec2.CreateTrafficMirrorFilterInput) (*request.Request, *ec2.CreateTrafficMirrorFilterOutput) {
---
> // CreateTransitGatewayRequest mocks base method
> func (m *MockEC2API) CreateTransitGatewayRequest(arg0 *ec2.CreateTransitGatewayInput) (*request.Request, *ec2.CreateTransitGatewayOutput) {
3626c3326
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayRequest", arg0)
3628c3328
< 	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterOutput)
---
> 	ret1, _ := ret[1].(*ec2.CreateTransitGatewayOutput)
3632,3633c3332,3333
< // CreateTrafficMirrorFilterRequest indicates an expected call of CreateTrafficMirrorFilterRequest
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call {
---
> // CreateTransitGatewayRequest indicates an expected call of CreateTransitGatewayRequest
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRequest(arg0 interface{}) *gomock.Call {
3635c3335
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRequest), arg0)
3638,3639c3338,3339
< // CreateTrafficMirrorFilterRule mocks base method
< func (m *MockEC2API) CreateTrafficMirrorFilterRule(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) {
---
> // CreateTransitGatewayRoute mocks base method
> func (m *MockEC2API) CreateTransitGatewayRoute(arg0 *ec2.CreateTransitGatewayRouteInput) (*ec2.CreateTransitGatewayRouteOutput, error) {
3641,3642c3341,3342
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRule", arg0)
< 	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayRoute", arg0)
> 	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput)
3647,3648c3347,3348
< // CreateTrafficMirrorFilterRule indicates an expected call of CreateTrafficMirrorFilterRule
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call {
---
> // CreateTransitGatewayRoute indicates an expected call of CreateTransitGatewayRoute
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRoute(arg0 interface{}) *gomock.Call {
3650c3350
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRule), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRoute), arg0)
3653,3654c3353,3354
< // CreateTrafficMirrorFilterRuleWithContext mocks base method
< func (m *MockEC2API) CreateTrafficMirrorFilterRuleWithContext(arg0 aws.Context, arg1 *ec2.CreateTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) {
---
> // CreateTransitGatewayRouteWithContext mocks base method
> func (m *MockEC2API) CreateTransitGatewayRouteWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteOutput, error) {
3660,3661c3360,3361
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleWithContext", varargs...)
< 	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteWithContext", varargs...)
> 	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput)
3666,3667c3366,3367
< // CreateTrafficMirrorFilterRuleWithContext indicates an expected call of CreateTrafficMirrorFilterRuleWithContext
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
---
> // CreateTransitGatewayRouteWithContext indicates an expected call of CreateTransitGatewayRouteWithContext
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
3670c3370
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteWithContext), varargs...)
3673,3674c3373,3374
< // CreateTrafficMirrorFilterRuleRequest mocks base method
< func (m *MockEC2API) CreateTrafficMirrorFilterRuleRequest(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*request.Request, *ec2.CreateTrafficMirrorFilterRuleOutput) {
---
> // CreateTransitGatewayRouteRequest mocks base method
> func (m *MockEC2API) CreateTransitGatewayRouteRequest(arg0 *ec2.CreateTransitGatewayRouteInput) (*request.Request, *ec2.CreateTransitGatewayRouteOutput) {
3676c3376
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteRequest", arg0)
3678c3378
< 	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterRuleOutput)
---
> 	ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteOutput)
3682,3683c3382,3383
< // CreateTrafficMirrorFilterRuleRequest indicates an expected call of CreateTrafficMirrorFilterRuleRequest
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call {
---
> // CreateTransitGatewayRouteRequest indicates an expected call of CreateTransitGatewayRouteRequest
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call {
3685c3385
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteRequest), arg0)
3688,3689c3388,3389
< // CreateTrafficMirrorSession mocks base method
< func (m *MockEC2API) CreateTrafficMirrorSession(arg0 *ec2.CreateTrafficMirrorSessionInput) (*ec2.CreateTrafficMirrorSessionOutput, error) {
---
> // CreateTransitGatewayRouteTable mocks base method
> func (m *MockEC2API) CreateTransitGatewayRouteTable(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*ec2.CreateTransitGatewayRouteTableOutput, error) {
3691,3692c3391,3392
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorSession", arg0)
< 	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTable", arg0)
> 	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput)
3697,3698c3397,3398
< // CreateTrafficMirrorSession indicates an expected call of CreateTrafficMirrorSession
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSession(arg0 interface{}) *gomock.Call {
---
> // CreateTransitGatewayRouteTable indicates an expected call of CreateTransitGatewayRouteTable
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call {
3700c3400
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSession), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTable), arg0)
3703,3704c3403,3404
< // CreateTrafficMirrorSessionWithContext mocks base method
< func (m *MockEC2API) CreateTrafficMirrorSessionWithContext(arg0 aws.Context, arg1 *ec2.CreateTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorSessionOutput, error) {
---
> // CreateTransitGatewayRouteTableWithContext mocks base method
> func (m *MockEC2API) CreateTransitGatewayRouteTableWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableOutput, error) {
3710,3711c3410,3411
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionWithContext", varargs...)
< 	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableWithContext", varargs...)
> 	ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput)
3716,3717c3416,3417
< // CreateTrafficMirrorSessionWithContext indicates an expected call of CreateTrafficMirrorSessionWithContext
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
---
> // CreateTransitGatewayRouteTableWithContext indicates an expected call of CreateTransitGatewayRouteTableWithContext
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
3720c3420
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableWithContext), varargs...)
3723,3724c3423,3424
< // CreateTrafficMirrorSessionRequest mocks base method
< func (m *MockEC2API) CreateTrafficMirrorSessionRequest(arg0 *ec2.CreateTrafficMirrorSessionInput) (*request.Request, *ec2.CreateTrafficMirrorSessionOutput) {
---
> // CreateTransitGatewayRouteTableRequest mocks base method
> func (m *MockEC2API) CreateTransitGatewayRouteTableRequest(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableOutput) {
3726c3426
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableRequest", arg0)
3728c3428
< 	ret1, _ := ret[1].(*ec2.CreateTrafficMirrorSessionOutput)
---
> 	ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableOutput)
3732,3733c3432,3433
< // CreateTrafficMirrorSessionRequest indicates an expected call of CreateTrafficMirrorSessionRequest
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call {
---
> // CreateTransitGatewayRouteTableRequest indicates an expected call of CreateTransitGatewayRouteTableRequest
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call {
3735c3435
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableRequest), arg0)
3738,3739c3438,3439
< // CreateTrafficMirrorTarget mocks base method
< func (m *MockEC2API) CreateTrafficMirrorTarget(arg0 *ec2.CreateTrafficMirrorTargetInput) (*ec2.CreateTrafficMirrorTargetOutput, error) {
---
> // CreateTransitGatewayVpcAttachment mocks base method
> func (m *MockEC2API) CreateTransitGatewayVpcAttachment(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) {
3741,3742c3441,3442
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorTarget", arg0)
< 	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachment", arg0)
> 	ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
3747,3748c3447,3448
< // CreateTrafficMirrorTarget indicates an expected call of CreateTrafficMirrorTarget
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTarget(arg0 interface{}) *gomock.Call {
---
> // CreateTransitGatewayVpcAttachment indicates an expected call of CreateTransitGatewayVpcAttachment
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call {
3750c3450
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTarget), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachment), arg0)
3753,3754c3453,3454
< // CreateTrafficMirrorTargetWithContext mocks base method
< func (m *MockEC2API) CreateTrafficMirrorTargetWithContext(arg0 aws.Context, arg1 *ec2.CreateTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorTargetOutput, error) {
---
> // CreateTransitGatewayVpcAttachmentWithContext mocks base method
> func (m *MockEC2API) CreateTransitGatewayVpcAttachmentWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) {
3760,3761c3460,3461
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetWithContext", varargs...)
< 	ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentWithContext", varargs...)
> 	ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
3766,3767c3466,3467
< // CreateTrafficMirrorTargetWithContext indicates an expected call of CreateTrafficMirrorTargetWithContext
< func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
---
> // CreateTransitGatewayVpcAttachmentWithContext indicates an expected call of CreateTransitGatewayVpcAttachmentWithContext
> func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
3770c3470
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentWithContext), varargs...)
3773,3774c3473,3474
< // CreateTrafficMirrorTargetRequest mocks base method
< func (m *MockEC2API) CreateTrafficMirrorTargetRequest(arg0 *ec2.CreateTrafficMirrorTargetInput) (*request.Request, *ec2.CreateTrafficMirrorTargetOutput) {
---
> // CreateTransitGatewayVpcAttachmentRequest mocks base method
> func (m *MockEC2API) CreateTransitGatewayVpcAttachmentRequest(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayVpcAttachmentOutput) {
3776c3476
< 	ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentRequest", arg0)
3778,3978c3478
< 	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)
< }
< 
< // 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)
< }
< 
< // CreateTransitGatewayWithContext mocks base method
< func (m *MockEC2API) CreateTransitGatewayWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // CreateTransitGatewayRouteWithContext mocks base method
< func (m *MockEC2API) CreateTransitGatewayRouteWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // CreateTransitGatewayRouteTableWithContext mocks base method
< func (m *MockEC2API) CreateTransitGatewayRouteTableWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // CreateTransitGatewayVpcAttachmentWithContext mocks base method
< func (m *MockEC2API) CreateTransitGatewayVpcAttachmentWithContext(arg0 aws.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...)
< }
< 
< // 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)
---
> 	ret1, _ := ret[1].(*ec2.CreateTransitGatewayVpcAttachmentOutput)
4438,4537d3937
< // 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)
< }
< 
< // DeleteClientVpnEndpointWithContext mocks base method
< func (m *MockEC2API) DeleteClientVpnEndpointWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // DeleteClientVpnRouteWithContext mocks base method
< func (m *MockEC2API) DeleteClientVpnRouteWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
5688,5889c5088,5089
< // 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)
< }
< 
< // DeleteTrafficMirrorFilterWithContext mocks base method
< func (m *MockEC2API) DeleteTrafficMirrorFilterWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // DeleteTrafficMirrorFilterRuleWithContext mocks base method
< func (m *MockEC2API) DeleteTrafficMirrorFilterRuleWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // DeleteTrafficMirrorSessionWithContext mocks base method
< func (m *MockEC2API) DeleteTrafficMirrorSessionWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // DeleteTrafficMirrorTargetWithContext mocks base method
< func (m *MockEC2API) DeleteTrafficMirrorTargetWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // DeleteTransitGateway mocks base method
< func (m *MockEC2API) DeleteTransitGateway(arg0 *ec2.DeleteTransitGatewayInput) (*ec2.DeleteTransitGatewayOutput, error) {
---
> // DeleteTransitGateway mocks base method
> func (m *MockEC2API) DeleteTransitGateway(arg0 *ec2.DeleteTransitGatewayInput) (*ec2.DeleteTransitGatewayOutput, error) {
6938,6970d6137
< // 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 aws.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...)
< }
< 
7021,7053d6187
< // 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 aws.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...)
< }
< 
7104,7138c6238,6239
< // 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 aws.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...)
< }
< 
< // DescribeClientVpnAuthorizationRules mocks base method
< func (m *MockEC2API) DescribeClientVpnAuthorizationRules(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) {
---
> // DescribeConversionTasks mocks base method
> func (m *MockEC2API) DescribeConversionTasks(arg0 *ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error) {
7140,7141c6241,6242
< 	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRules", arg0)
< 	ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
---
> 	ret := m.ctrl.Call(m, "DescribeConversionTasks", arg0)
> 	ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput)
7146,7147c6247,6248
< // DescribeClientVpnAuthorizationRules indicates an expected call of DescribeClientVpnAuthorizationRules
< func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRules(arg0 interface{}) *gomock.Call {
---
> // DescribeConversionTasks indicates an expected call of DescribeConversionTasks
> func (mr *MockEC2APIMockRecorder) DescribeConversionTasks(arg0 interface{}) *gomock.Call {
7149c6250
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRules", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRules), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasks), arg0)
7152,7153c6253,6254
< // DescribeClientVpnAuthorizationRulesWithContext mocks base method
< func (m *MockEC2API) DescribeClientVpnAuthorizationRulesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) {
---
> // DescribeConversionTasksWithContext mocks base method
> func (m *MockEC2API) DescribeConversionTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.Option) (*ec2.DescribeConversionTasksOutput, error) {
7159,7160c6260,6261
< 	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesWithContext", varargs...)
< 	ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
---
> 	ret := m.ctrl.Call(m, "DescribeConversionTasksWithContext", varargs...)
> 	ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput)
7165,7166c6266,6267
< // DescribeClientVpnAuthorizationRulesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesWithContext
< func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
---
> // DescribeConversionTasksWithContext indicates an expected call of DescribeConversionTasksWithContext
> func (mr *MockEC2APIMockRecorder) DescribeConversionTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
7169c6270
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksWithContext), varargs...)
7172,7173c6273,6274
< // DescribeClientVpnAuthorizationRulesRequest mocks base method
< func (m *MockEC2API) DescribeClientVpnAuthorizationRulesRequest(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*request.Request, *ec2.DescribeClientVpnAuthorizationRulesOutput) {
---
> // DescribeConversionTasksRequest mocks base method
> func (m *MockEC2API) DescribeConversionTasksRequest(arg0 *ec2.DescribeConversionTasksInput) (*request.Request, *ec2.DescribeConversionTasksOutput) {
7175c6276
< 	ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "DescribeConversionTasksRequest", arg0)
7177c6278
< 	ret1, _ := ret[1].(*ec2.DescribeClientVpnAuthorizationRulesOutput)
---
> 	ret1, _ := ret[1].(*ec2.DescribeConversionTasksOutput)
7181,7214c6282,6283
< // 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)
< }
< 
< // 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 aws.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 {
---
> // DescribeConversionTasksRequest indicates an expected call of DescribeConversionTasksRequest
> func (mr *MockEC2APIMockRecorder) DescribeConversionTasksRequest(arg0 interface{}) *gomock.Call {
7216,7217c6285
< 	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPagesWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksRequest), arg0)
7220,7221c6288,6289
< // DescribeClientVpnConnections mocks base method
< func (m *MockEC2API) DescribeClientVpnConnections(arg0 *ec2.DescribeClientVpnConnectionsInput) (*ec2.DescribeClientVpnConnectionsOutput, error) {
---
> // DescribeCustomerGateways mocks base method
> func (m *MockEC2API) DescribeCustomerGateways(arg0 *ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error) {
7223,7224c6291,6292
< 	ret := m.ctrl.Call(m, "DescribeClientVpnConnections", arg0)
< 	ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput)
---
> 	ret := m.ctrl.Call(m, "DescribeCustomerGateways", arg0)
> 	ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput)
7229,7230c6297,6298
< // DescribeClientVpnConnections indicates an expected call of DescribeClientVpnConnections
< func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnections(arg0 interface{}) *gomock.Call {
---
> // DescribeCustomerGateways indicates an expected call of DescribeCustomerGateways
> func (mr *MockEC2APIMockRecorder) DescribeCustomerGateways(arg0 interface{}) *gomock.Call {
7232c6300
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnections), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGateways), arg0)
7235,7236c6303,6304
< // DescribeClientVpnConnectionsWithContext mocks base method
< func (m *MockEC2API) DescribeClientVpnConnectionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnConnectionsOutput, error) {
---
> // DescribeCustomerGatewaysWithContext mocks base method
> func (m *MockEC2API) DescribeCustomerGatewaysWithContext(arg0 aws.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCustomerGatewaysOutput, error) {
7242,7243c6310,6311
< 	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsWithContext", varargs...)
< 	ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput)
---
> 	ret := m.ctrl.Call(m, "DescribeCustomerGatewaysWithContext", varargs...)
> 	ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput)
7248,7249c6316,6317
< // DescribeClientVpnConnectionsWithContext indicates an expected call of DescribeClientVpnConnectionsWithContext
< func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
---
> // DescribeCustomerGatewaysWithContext indicates an expected call of DescribeCustomerGatewaysWithContext
> func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
7252c6320
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysWithContext), varargs...)
7255,7256c6323,6324
< // DescribeClientVpnConnectionsRequest mocks base method
< func (m *MockEC2API) DescribeClientVpnConnectionsRequest(arg0 *ec2.DescribeClientVpnConnectionsInput) (*request.Request, *ec2.DescribeClientVpnConnectionsOutput) {
---
> // DescribeCustomerGatewaysRequest mocks base method
> func (m *MockEC2API) DescribeCustomerGatewaysRequest(arg0 *ec2.DescribeCustomerGatewaysInput) (*request.Request, *ec2.DescribeCustomerGatewaysOutput) {
7258c6326
< 	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "DescribeCustomerGatewaysRequest", arg0)
7260c6328
< 	ret1, _ := ret[1].(*ec2.DescribeClientVpnConnectionsOutput)
---
> 	ret1, _ := ret[1].(*ec2.DescribeCustomerGatewaysOutput)
7264,7265c6332,6333
< // DescribeClientVpnConnectionsRequest indicates an expected call of DescribeClientVpnConnectionsRequest
< func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call {
---
> // DescribeCustomerGatewaysRequest indicates an expected call of DescribeCustomerGatewaysRequest
> func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysRequest(arg0 interface{}) *gomock.Call {
7267c6335
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysRequest), arg0)
7270,7271c6338,6339
< // DescribeClientVpnConnectionsPages mocks base method
< func (m *MockEC2API) DescribeClientVpnConnectionsPages(arg0 *ec2.DescribeClientVpnConnectionsInput, arg1 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool) error {
---
> // DescribeDhcpOptions mocks base method
> func (m *MockEC2API) DescribeDhcpOptions(arg0 *ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) {
7273,7275c6341,6344
< 	ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPages", arg0, arg1)
< 	ret0, _ := ret[0].(error)
< 	return ret0
---
> 	ret := m.ctrl.Call(m, "DescribeDhcpOptions", arg0)
> 	ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput)
> 	ret1, _ := ret[1].(error)
> 	return ret0, ret1
7278,7279c6347,6348
< // DescribeClientVpnConnectionsPages indicates an expected call of DescribeClientVpnConnectionsPages
< func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPages(arg0, arg1 interface{}) *gomock.Call {
---
> // DescribeDhcpOptions indicates an expected call of DescribeDhcpOptions
> func (mr *MockEC2APIMockRecorder) DescribeDhcpOptions(arg0 interface{}) *gomock.Call {
7281,7664c6350
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPages), arg0, arg1)
< }
< 
< // DescribeClientVpnConnectionsPagesWithContext mocks base method
< func (m *MockEC2API) DescribeClientVpnConnectionsPagesWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // DescribeClientVpnEndpointsWithContext mocks base method
< func (m *MockEC2API) DescribeClientVpnEndpointsWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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 aws.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...)
< }
< 
< // 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)
< }
< 
< // DescribeClientVpnRoutesWithContext mocks base method
< func (m *MockEC2API) DescribeClientVpnRoutesWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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 aws.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...)
< }
< 
< // 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)
< }
< 
< // DescribeClientVpnTargetNetworksWithContext mocks base method
< func (m *MockEC2API) DescribeClientVpnTargetNetworksWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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 aws.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...)
< }
< 
< // 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)
< }
< 
< // DescribeConversionTasksWithContext mocks base method
< func (m *MockEC2API) DescribeConversionTasksWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // DescribeCustomerGatewaysWithContext mocks base method
< func (m *MockEC2API) DescribeCustomerGatewaysWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptions), arg0)
7702,7734d6387
< // 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 aws.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...)
< }
< 
7785,7817d6437
< // 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 aws.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...)
< }
< 
8068,8100d6687
< // 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 aws.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...)
< }
< 
8151,8183d6737
< // 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 aws.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...)
< }
< 
8284,8316d6837
< // 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 aws.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...)
< }
< 
8367,8399d6887
< // 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 aws.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...)
< }
< 
8450,8482d6937
< // 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 aws.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...)
< }
< 
8533,8565d6987
< // 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 aws.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...)
< }
< 
8616,8648d7037
< // 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 aws.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...)
< }
< 
8894,8926c7283
< 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)
< }
< 
< // 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 aws.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 {
---
> func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksRequest(arg0 interface{}) *gomock.Call {
8928,8929c7285
< 	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPagesWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksRequest), arg0)
8982,9014d7337
< // 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 aws.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...)
< }
< 
9115,9147d7437
< // 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 aws.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...)
< }
< 
9364,9396d7653
< // 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 aws.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...)
< }
< 
9497,9529d7753
< // 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 aws.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...)
< }
< 
9580,9612d7803
< // 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 aws.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...)
< }
< 
9663,9695d7853
< // 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 aws.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...)
< }
< 
9829,9861d7986
< // 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 aws.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...)
< }
< 
9962,9994d8086
< // 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 aws.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...)
< }
< 
10178,10210d8269
< // 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 aws.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...)
< }
< 
10261,10293d8319
< // 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 aws.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...)
< }
< 
10344,10376d8369
< // 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 aws.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...)
< }
< 
10823,10856c8816
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityRequest), 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 aws.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...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityRequest), arg0)
10909,10941d8868
< // 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 aws.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...)
< }
< 
11491,11523d9417
< // 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 aws.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...)
< }
< 
11657,11689d9550
< // 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 aws.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...)
< }
< 
11740,11772d9600
< // 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 aws.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...)
< }
< 
11802,12051c9630
< 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...)
< }
< 
< // 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)
< }
< 
< // 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 aws.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...)
< }
< 
< // 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)
< }
< 
< // DescribeTrafficMirrorFiltersWithContext mocks base method
< func (m *MockEC2API) DescribeTrafficMirrorFiltersWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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 aws.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...)
< }
< 
< // 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)
< }
< 
< // DescribeTrafficMirrorSessionsWithContext mocks base method
< func (m *MockEC2API) DescribeTrafficMirrorSessionsWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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 aws.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...)
< }
< 
< // 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)
< }
< 
< // DescribeTrafficMirrorTargetsWithContext mocks base method
< func (m *MockEC2API) DescribeTrafficMirrorTargetsWithContext(arg0 aws.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 {
---
> func (mr *MockEC2APIMockRecorder) DescribeTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
12054c9633
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsWithContext), varargs...)
12057,12058c9636,9637
< // DescribeTrafficMirrorTargetsRequest mocks base method
< func (m *MockEC2API) DescribeTrafficMirrorTargetsRequest(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*request.Request, *ec2.DescribeTrafficMirrorTargetsOutput) {
---
> // DescribeTagsRequest mocks base method
> func (m *MockEC2API) DescribeTagsRequest(arg0 *ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput) {
12060c9639
< 	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0)
12062c9641
< 	ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorTargetsOutput)
---
> 	ret1, _ := ret[1].(*ec2.DescribeTagsOutput)
12066,12067c9645,9646
< // DescribeTrafficMirrorTargetsRequest indicates an expected call of DescribeTrafficMirrorTargetsRequest
< func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsRequest(arg0 interface{}) *gomock.Call {
---
> // DescribeTagsRequest indicates an expected call of DescribeTagsRequest
> func (mr *MockEC2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call {
12069c9648
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsRequest), arg0)
12072,12073c9651,9652
< // DescribeTrafficMirrorTargetsPages mocks base method
< func (m *MockEC2API) DescribeTrafficMirrorTargetsPages(arg0 *ec2.DescribeTrafficMirrorTargetsInput, arg1 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool) error {
---
> // DescribeTagsPages mocks base method
> func (m *MockEC2API) DescribeTagsPages(arg0 *ec2.DescribeTagsInput, arg1 func(*ec2.DescribeTagsOutput, bool) bool) error {
12075c9654
< 	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPages", arg0, arg1)
---
> 	ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1)
12080,12081c9659,9660
< // DescribeTrafficMirrorTargetsPages indicates an expected call of DescribeTrafficMirrorTargetsPages
< func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPages(arg0, arg1 interface{}) *gomock.Call {
---
> // DescribeTagsPages indicates an expected call of DescribeTagsPages
> func (mr *MockEC2APIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call {
12083c9662
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPages), arg0, arg1)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPages), arg0, arg1)
12086,12087c9665,9666
< // DescribeTrafficMirrorTargetsPagesWithContext mocks base method
< func (m *MockEC2API) DescribeTrafficMirrorTargetsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool, arg3 ...request.Option) error {
---
> // DescribeTagsPagesWithContext mocks base method
> func (m *MockEC2API) DescribeTagsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTagsInput, arg2 func(*ec2.DescribeTagsOutput, bool) bool, arg3 ...request.Option) error {
12093c9672
< 	ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPagesWithContext", varargs...)
---
> 	ret := m.ctrl.Call(m, "DescribeTagsPagesWithContext", varargs...)
12098,12099c9677,9678
< // DescribeTrafficMirrorTargetsPagesWithContext indicates an expected call of DescribeTrafficMirrorTargetsPagesWithContext
< func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
---
> // DescribeTagsPagesWithContext indicates an expected call of DescribeTagsPagesWithContext
> func (mr *MockEC2APIMockRecorder) DescribeTagsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
12102c9681
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPagesWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPagesWithContext), varargs...)
12155,12187d9733
< // 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 aws.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...)
< }
< 
12238,12270d9783
< // 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 aws.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...)
< }
< 
12321,12353d9833
< // 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 aws.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...)
< }
< 
12404,12436d9883
< // 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 aws.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...)
< }
< 
12703,12735d10149
< // 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 aws.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...)
< }
< 
12886,12918d10299
< // 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 aws.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...)
< }
< 
12969,13001d10349
< // 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 aws.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...)
< }
< 
13052,13084d10399
< // 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 aws.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...)
< }
< 
13135,13167d10449
< // 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 aws.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...)
< }
< 
13218,13250d10499
< // 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 aws.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...)
< }
< 
13332,13362c10581,10582
< 	varargs := append([]interface{}{arg0, arg1}, arg2...)
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsWithContext), 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)
< }
< 
< // 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)
---
> 	varargs := append([]interface{}{arg0, arg1}, arg2...)
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsWithContext), varargs...)
13365,13366c10585,10586
< // DescribeVpcEndpointsPagesWithContext mocks base method
< func (m *MockEC2API) DescribeVpcEndpointsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 func(*ec2.DescribeVpcEndpointsOutput, bool) bool, arg3 ...request.Option) error {
---
> // DescribeVpcEndpointsRequest mocks base method
> func (m *MockEC2API) DescribeVpcEndpointsRequest(arg0 *ec2.DescribeVpcEndpointsInput) (*request.Request, *ec2.DescribeVpcEndpointsOutput) {
13368,13374c10588,10591
< 	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
---
> 	ret := m.ctrl.Call(m, "DescribeVpcEndpointsRequest", arg0)
> 	ret0, _ := ret[0].(*request.Request)
> 	ret1, _ := ret[1].(*ec2.DescribeVpcEndpointsOutput)
> 	return ret0, ret1
13377,13378c10594,10595
< // DescribeVpcEndpointsPagesWithContext indicates an expected call of DescribeVpcEndpointsPagesWithContext
< func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
---
> // DescribeVpcEndpointsRequest indicates an expected call of DescribeVpcEndpointsRequest
> func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsRequest(arg0 interface{}) *gomock.Call {
13380,13381c10597
< 	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPagesWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsRequest), arg0)
13434,13466d10649
< // 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 aws.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...)
< }
< 
13517,13549d10699
< // 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 aws.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...)
< }
< 
13900,13949d11049
< // 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)
< }
< 
< // DisableEbsEncryptionByDefaultWithContext mocks base method
< func (m *MockEC2API) DisableEbsEncryptionByDefaultWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
14200,14249d11299
< // 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)
< }
< 
< // DisassociateClientVpnTargetNetworkWithContext mocks base method
< func (m *MockEC2API) DisassociateClientVpnTargetNetworkWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
14500,14549d11549
< // 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)
< }
< 
< // EnableEbsEncryptionByDefaultWithContext mocks base method
< func (m *MockEC2API) EnableEbsEncryptionByDefaultWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
14795,14945c11795
< 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)
< }
< 
< // 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)
< }
< 
< // ExportClientVpnClientCertificateRevocationListWithContext mocks base method
< func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // ExportClientVpnClientConfigurationWithContext mocks base method
< func (m *MockEC2API) ExportClientVpnClientConfigurationWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // ExportTransitGatewayRoutesWithContext mocks base method
< func (m *MockEC2API) ExportTransitGatewayRoutesWithContext(arg0 aws.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...)
< }
< 
< // 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 {
---
> func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call {
14947c11797
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportRequest), arg0)
14950,14951c11800,11801
< // GetCapacityReservationUsage mocks base method
< func (m *MockEC2API) GetCapacityReservationUsage(arg0 *ec2.GetCapacityReservationUsageInput) (*ec2.GetCapacityReservationUsageOutput, error) {
---
> // ExportTransitGatewayRoutes mocks base method
> func (m *MockEC2API) ExportTransitGatewayRoutes(arg0 *ec2.ExportTransitGatewayRoutesInput) (*ec2.ExportTransitGatewayRoutesOutput, error) {
14953,14954c11803,11804
< 	ret := m.ctrl.Call(m, "GetCapacityReservationUsage", arg0)
< 	ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput)
---
> 	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutes", arg0)
> 	ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput)
14959,14960c11809,11810
< // GetCapacityReservationUsage indicates an expected call of GetCapacityReservationUsage
< func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsage(arg0 interface{}) *gomock.Call {
---
> // ExportTransitGatewayRoutes indicates an expected call of ExportTransitGatewayRoutes
> func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutes(arg0 interface{}) *gomock.Call {
14962c11812
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsage", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsage), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutes), arg0)
14965,14966c11815,11816
< // GetCapacityReservationUsageWithContext mocks base method
< func (m *MockEC2API) GetCapacityReservationUsageWithContext(arg0 aws.Context, arg1 *ec2.GetCapacityReservationUsageInput, arg2 ...request.Option) (*ec2.GetCapacityReservationUsageOutput, error) {
---
> // ExportTransitGatewayRoutesWithContext mocks base method
> func (m *MockEC2API) ExportTransitGatewayRoutesWithContext(arg0 aws.Context, arg1 *ec2.ExportTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.ExportTransitGatewayRoutesOutput, error) {
14972,14973c11822,11823
< 	ret := m.ctrl.Call(m, "GetCapacityReservationUsageWithContext", varargs...)
< 	ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput)
---
> 	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesWithContext", varargs...)
> 	ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput)
14978,14979c11828,11829
< // GetCapacityReservationUsageWithContext indicates an expected call of GetCapacityReservationUsageWithContext
< func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
---
> // ExportTransitGatewayRoutesWithContext indicates an expected call of ExportTransitGatewayRoutesWithContext
> func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
14982c11832
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageWithContext", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesWithContext), varargs...)
14985,14986c11835,11836
< // GetCapacityReservationUsageRequest mocks base method
< func (m *MockEC2API) GetCapacityReservationUsageRequest(arg0 *ec2.GetCapacityReservationUsageInput) (*request.Request, *ec2.GetCapacityReservationUsageOutput) {
---
> // ExportTransitGatewayRoutesRequest mocks base method
> func (m *MockEC2API) ExportTransitGatewayRoutesRequest(arg0 *ec2.ExportTransitGatewayRoutesInput) (*request.Request, *ec2.ExportTransitGatewayRoutesOutput) {
14988c11838
< 	ret := m.ctrl.Call(m, "GetCapacityReservationUsageRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesRequest", arg0)
14990c11840
< 	ret1, _ := ret[1].(*ec2.GetCapacityReservationUsageOutput)
---
> 	ret1, _ := ret[1].(*ec2.ExportTransitGatewayRoutesOutput)
14994,14995c11844,11845
< // GetCapacityReservationUsageRequest indicates an expected call of GetCapacityReservationUsageRequest
< func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageRequest(arg0 interface{}) *gomock.Call {
---
> // ExportTransitGatewayRoutesRequest indicates an expected call of ExportTransitGatewayRoutesRequest
> func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call {
14997c11847
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesRequest), arg0)
15100,15199d11949
< // 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)
< }
< 
< // GetEbsDefaultKmsKeyIdWithContext mocks base method
< func (m *MockEC2API) GetEbsDefaultKmsKeyIdWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // GetEbsEncryptionByDefaultWithContext mocks base method
< func (m *MockEC2API) GetEbsEncryptionByDefaultWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
15450,15482d12199
< // 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 aws.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...)
< }
< 
15533,15565d12249
< // 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 aws.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...)
< }
< 
15616,15698d12299
< // 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 aws.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...)
< }
< 
< // 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)
< }
< 
< // ImportClientVpnClientCertificateRevocationListWithContext mocks base method
< func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
15943,16044c12544,12545
< // 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)
< }
< 
< // 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)
< }
< 
< // ModifyCapacityReservationWithContext mocks base method
< func (m *MockEC2API) ModifyCapacityReservationWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // ModifyClientVpnEndpointWithContext mocks base method
< func (m *MockEC2API) ModifyClientVpnEndpointWithContext(arg0 aws.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...)
< }
< 
< // 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 {
---
> // ImportVolumeRequest indicates an expected call of ImportVolumeRequest
> func (mr *MockEC2APIMockRecorder) ImportVolumeRequest(arg0 interface{}) *gomock.Call {
16046c12547
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeRequest), arg0)
16049,16050c12550,12551
< // ModifyEbsDefaultKmsKeyId mocks base method
< func (m *MockEC2API) ModifyEbsDefaultKmsKeyId(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) {
---
> // ModifyCapacityReservation mocks base method
> func (m *MockEC2API) ModifyCapacityReservation(arg0 *ec2.ModifyCapacityReservationInput) (*ec2.ModifyCapacityReservationOutput, error) {
16052,16053c12553,12554
< 	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyId", arg0)
< 	ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
---
> 	ret := m.ctrl.Call(m, "ModifyCapacityReservation", arg0)
> 	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput)
16058,16059c12559,12560
< // ModifyEbsDefaultKmsKeyId indicates an expected call of ModifyEbsDefaultKmsKeyId
< func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call {
---
> // ModifyCapacityReservation indicates an expected call of ModifyCapacityReservation
> func (mr *MockEC2APIMockRecorder) ModifyCapacityReservation(arg0 interface{}) *gomock.Call {
16061c12562
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyId), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservation), arg0)
16064,16065c12565,12566
< // ModifyEbsDefaultKmsKeyIdWithContext mocks base method
< func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdWithContext(arg0 aws.Context, arg1 *ec2.ModifyEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) {
---
> // ModifyCapacityReservationWithContext mocks base method
> func (m *MockEC2API) ModifyCapacityReservationWithContext(arg0 aws.Context, arg1 *ec2.ModifyCapacityReservationInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationOutput, error) {
16071,16072c12572,12573
< 	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdWithContext", varargs...)
< 	ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
---
> 	ret := m.ctrl.Call(m, "ModifyCapacityReservationWithContext", varargs...)
> 	ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput)
16077,16078c12578,12579
< // ModifyEbsDefaultKmsKeyIdWithContext indicates an expected call of ModifyEbsDefaultKmsKeyIdWithContext
< func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
---
> // ModifyCapacityReservationWithContext indicates an expected call of ModifyCapacityReservationWithContext
> func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
16081c12582
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdWithContext), varargs...)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationWithContext), varargs...)
16084,16085c12585,12586
< // ModifyEbsDefaultKmsKeyIdRequest mocks base method
< func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdRequest(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ModifyEbsDefaultKmsKeyIdOutput) {
---
> // ModifyCapacityReservationRequest mocks base method
> func (m *MockEC2API) ModifyCapacityReservationRequest(arg0 *ec2.ModifyCapacityReservationInput) (*request.Request, *ec2.ModifyCapacityReservationOutput) {
16087c12588
< 	ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdRequest", arg0)
---
> 	ret := m.ctrl.Call(m, "ModifyCapacityReservationRequest", arg0)
16089c12590
< 	ret1, _ := ret[1].(*ec2.ModifyEbsDefaultKmsKeyIdOutput)
---
> 	ret1, _ := ret[1].(*ec2.ModifyCapacityReservationOutput)
16093,16094c12594,12595
< // ModifyEbsDefaultKmsKeyIdRequest indicates an expected call of ModifyEbsDefaultKmsKeyIdRequest
< func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call {
---
> // ModifyCapacityReservationRequest indicates an expected call of ModifyCapacityReservationRequest
> func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationRequest(arg0 interface{}) *gomock.Call {
16096c12597
< 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdRequest), arg0)
---
> 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationRequest), arg0)
16549,16598d13049
< // 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)
< }
< 
< // ModifyInstanceEventStartTimeWithContext mocks base method
< func (m *MockEC2API) ModifyInstanceEventStartTimeWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
16949,17098d13399
< // 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)
< }
< 
< // ModifyTrafficMirrorFilterNetworkServicesWithContext mocks base method
< func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // ModifyTrafficMirrorFilterRuleWithContext mocks base method
< func (m *MockEC2API) ModifyTrafficMirrorFilterRuleWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
< // 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)
< }
< 
< // ModifyTrafficMirrorSessionWithContext mocks base method
< func (m *MockEC2API) ModifyTrafficMirrorSessionWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
17599,17648d13899
< // 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)
< }
< 
< // ModifyVpnConnectionWithContext mocks base method
< func (m *MockEC2API) ModifyVpnConnectionWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
18749,18798d14999
< // 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)
< }
< 
< // ResetEbsDefaultKmsKeyIdWithContext mocks base method
< func (m *MockEC2API) ResetEbsDefaultKmsKeyIdWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
19099,19148d15299
< // 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)
< }
< 
< // RevokeClientVpnIngressWithContext mocks base method
< func (m *MockEC2API) RevokeClientVpnIngressWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
< 
19499,19548d15649
< // 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)
< }
< 
< // TerminateClientVpnConnectionsWithContext mocks base method
< func (m *MockEC2API) TerminateClientVpnConnectionsWithContext(arg0 aws.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...)
< }
< 
< // 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)
< }
<